parser.pegjs: add line/column to generated nodes

parser must be generated with the following option:

pegjs --track-line-and-column -e smalltalk.parser parser.pegjs parser.js

js/parser.pegjs

@@ -9,7 +9,8 @@ keyword        = first:identifier last:[:] {return first + last}
 className      = first:[A-Z] others:[a-zA-Z0-9]* {return first + others.join("")}
 string         = ['] val:(("''" {return "'"} / [^'])*) ['] {
                      return smalltalk.ValueNode._new()
-                            ._value_(val.join("").replace(/\"/ig, '"'))
+                            ._position_((line).__at(column))
+                            ._value_(val.join("").replace(/\"/ig, '"'));
                  }
 
 symbol         = "#"val:(
@@ -17,24 +18,29 @@ symbol         = "#"val:(
                        / node:string {return node._value()})*
                   {
                       return smalltalk.ValueNode._new()
+                             ._position_((line).__at(column))
                              ._value_(smalltalk.symbolFor(val.join("").replace(/\"/ig, '"')))
                   }
 number         = n:(float / integer) {
                      return smalltalk.ValueNode._new()
+                            ._position_((line).__at(column))
                             ._value_(n)
                  }
 float          = neg:[-]?int:[0-9]+ "." dec:[0-9]+ {return parseFloat((neg + int.join("") + "." + dec.join("")), 10)}
 integer        = neg:[-]?digits:[0-9]+ {return (parseInt(neg+digits.join(""), 10))}
 literalArray   = "#(" ws lits:(lit:literal ws {return lit._value()})* ws ")" {
                      return smalltalk.ValueNode._new()
+                            ._position_((line).__at(column))
                             ._value_(lits)
                  }
 dynamicArray   = "{" ws expressions:expressions? ws "."? "}" {
                      return smalltalk.DynamicArrayNode._new()
+                            ._position_((line).__at(column))
                             ._nodes_(expressions)
                  }
 dynamicDictionary = "#{" ws expressions: expressions? ws "}" {
                         return smalltalk.DynamicDictionaryNode._new()
+                               ._position_((line).__at(column))
                                ._nodes_(expressions)
                     }
 pseudoVariable = val:(
@@ -42,6 +48,7 @@ pseudoVariable = val:(
                  / 'false' {return false}
                  / 'nil' {return nil}) {
                        return smalltalk.ValueNode._new()
+                              ._position_((line).__at(column))
                               ._value_(val)
                    }
 literal        = pseudoVariable / number / literalArray / dynamicDictionary / dynamicArray / string / symbol / block
@@ -49,10 +56,12 @@ literal        = pseudoVariable / number / literalArray / dynamicDictionary / dy
 
 variable       = identifier:varIdentifier {
                      return smalltalk.VariableNode._new()
+                            ._position_((line).__at(column))
                             ._value_(identifier)
                  }
 classReference = className:className {
                      return smalltalk.ClassReferenceNode._new()
+                            ._position_((line).__at(column))
                             ._value_(className)
                  }
 
@@ -90,12 +99,14 @@ expressions    = first:expression others:expressionList* {
 
 assignment     = variable:variable ws ':=' ws expression:expression {
                      return smalltalk.AssignmentNode._new()
+                            ._position_((line).__at(column))
                             ._left_(variable)
                             ._right_(expression)
                  }
 
 ret            = '^' ws expression:expression ws '.'? {
                      return smalltalk.ReturnNode._new()
+                            ._position_((line).__at(column))
                             ._nodes_([expression])
                  }
   
@@ -117,12 +128,14 @@ statements     = ret:ret [.]* {return [ret]}
 
 sequence       = temps:temps? ws statements:statements? ws {
                      return smalltalk.SequenceNode._new()
+                            ._position_((line).__at(column))
                             ._temps_(temps || [])
                             ._nodes_(statements || [])
                  }
 
 block          = '[' ws params:blockParamList? ws sequence:sequence? ws ']' {
                      return smalltalk.BlockNode._new()
+                            ._position_((line).__at(column))
                             ._parameters_(params || [])
                             ._nodes_([sequence._asBlockSequenceNode()])
                  }
@@ -133,6 +146,7 @@ operand        = literal / reference / subexpression
 
 unaryMessage   = ws selector:unarySelector ![:] {
                      return smalltalk.SendNode._new()
+                            ._position_((line).__at(column))
                             ._selector_(selector)
                  }
 
@@ -156,6 +170,7 @@ unarySend      = receiver:operand ws tail:unaryTail? {
 
 binaryMessage  = ws selector:binarySelector ws arg:(unarySend / operand) {
                      return smalltalk.SendNode._new()
+                            ._position_((line).__at(column))
                             ._selector_(selector)
                             ._arguments_([arg])
                  }
@@ -187,6 +202,7 @@ keywordMessage = ws pairs:(pair:keywordPair ws {return pair})+ {
                           args.push(pairs[i].arg);
                       }
                       return smalltalk.SendNode._new()
+                             ._position_((line).__at(column))
                              ._selector_(selector.join(""))
                              ._arguments_(args)
                  }
@@ -204,18 +220,21 @@ cascade        = ws send:(keywordSend / binarySend) messages:(ws ";" ws mess:mes
                          cascade.push(messages[i]);
                      }
                      return smalltalk.CascadeNode._new()
+                            ._position_((line).__at(column))
                             ._receiver_(send._receiver())
                             ._nodes_(cascade)
                  }
 
 jsStatement    = "<" val:((">>" {return ">"} / [^>])*) ">" {
                      return smalltalk.JSStatementNode._new()
+                            ._position_((line).__at(column))
                             ._source_(val.join(""))
                  }
 
 
 method         = ws pattern:(keywordPattern / binaryPattern / unaryPattern) ws sequence:sequence? ws {
                       return smalltalk.MethodNode._new()
+                             ._position_((line).__at(column))
                              ._selector_(pattern[0])
                              ._arguments_(pattern[1])
                              ._nodes_([sequence])