starlight-cli 1.0.46 → 1.0.48

package/src/parser.js

@@ -1,22 +1,51 @@
-class Parser {
-  constructor(tokens) {
-    this.tokens = tokens;
-    this.pos = 0;
-    this.current = this.tokens[this.pos];
+class ParseError extends Error {
+  constructor(message, token, source) {
+    const line = token?.line ?? '?';
+    const column = token?.column ?? '?';
+
+    let output = `SyntaxError: ${message}\n`;
+
+    if (source && token?.line != null) {
+      const lines = source.split('\n');
+      const srcLine = lines[token.line - 1] || '';
+      output += `  at line ${line}, column ${column}\n`;
+      output += `    ${srcLine}\n`;
+      output += `    ${' '.repeat(column - 1)}^\n`;
+    } else {
+      output += `  at line ${line}, column ${column}\n`;
+    }
+
+    super(output);
+    this.name = 'SyntaxError';
   }
+}
+
+class Parser {
+  constructor(tokens, source = '') {
+  this.tokens = tokens;
+  this.source = source;
+  this.pos = 0;
+  this.current = this.tokens[this.pos];
+}
+
 
   advance() {
     this.pos++;
     this.current = this.pos < this.tokens.length ? this.tokens[this.pos] : { type: 'EOF' };
   }
 
-  eat(type) {
-    if (this.current.type === type) this.advance();
-    else throw new Error(
-  `Expected ${type}, got ${this.current.type} at line ${this.current.line}, column ${this.current.column}`
-);
-
+ eat(type) {
+  if (this.current.type === type) {
+    this.advance();
+  } else {
+    throw new ParseError(
+      `Expected '${type}' but got '${this.current.type}'`,
+      this.current,
+      this.source
+    );
   }
+}
+
 
   peekType(offset = 1) {
     return (this.tokens[this.pos + offset] || { type: 'EOF' }).type;
@@ -54,10 +83,11 @@ class Parser {
         return this.expressionStatement();
     }
   }
-
-  varDeclaration() {
+varDeclaration() {
+  const t = this.current; // LET token
   this.eat('LET');
-  const id = this.current.value;
+  const idToken = this.current; // identifier token
+  const id = idToken.value;
   this.eat('IDENTIFIER');
 
   let expr = null;
@@ -69,16 +99,30 @@ class Parser {
   // semicolon optional
   if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
 
-  return { type: 'VarDeclaration', id, expr };
+  return { 
+    type: 'VarDeclaration', 
+    id, 
+    expr, 
+    line: t.line, 
+    column: t.column 
+  };
 }
 
 sldeployStatement() {
+  const t = this.current; // SLDEPLOY token
   this.eat('SLDEPLOY');
   const expr = this.expression();
   if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
-  return { type: 'SldeployStatement', expr };
+  return { 
+    type: 'SldeployStatement', 
+    expr, 
+    line: t.line, 
+    column: t.column 
+  };
 }
+
 doTrackStatement() {
+  const t = this.current; // DO token
   this.eat('DO');
 
   const body = this.block();
@@ -92,13 +136,17 @@ doTrackStatement() {
   return {
     type: 'DoTrackStatement',
     body,
-    handler
+    handler,
+    line: t.line,
+    column: t.column
   };
 }
 
 defineStatement() {
+  const t = this.current; // DEFINE token
   this.eat('DEFINE');
-  const id = this.current.value;
+  const idToken = this.current; // identifier token
+  const id = idToken.value;
   this.eat('IDENTIFIER');
 
   let expr = null;
@@ -109,10 +157,17 @@ defineStatement() {
 
   if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
 
-  return { type: 'DefineStatement', id, expr };
+  return { 
+    type: 'DefineStatement', 
+    id, 
+    expr, 
+    line: t.line, 
+    column: t.column 
+  };
 }
 
 asyncFuncDeclaration() {
+  const t = this.current; // first token of function (identifier)
   const name = this.current.value;
   this.eat('IDENTIFIER');
 
@@ -138,10 +193,19 @@ asyncFuncDeclaration() {
   }
 
   const body = this.block();
-  return { type: 'FunctionDeclaration', name, params, body, async: true };
+  return { 
+    type: 'FunctionDeclaration', 
+    name, 
+    params, 
+    body, 
+    async: true,
+    line: t.line,
+    column: t.column
+  };
 }
 
 ifStatement() {
+  const t = this.current; // IF token
   this.eat('IF');
 
   let test;
@@ -150,7 +214,7 @@ ifStatement() {
     test = this.expression();
     this.eat('RPAREN');
   } else {
-    // python style: no parentheses
+    // Python style: no parentheses
     test = this.expression();
   }
 
@@ -163,10 +227,18 @@ ifStatement() {
     else alternate = this.block();
   }
 
-  return { type: 'IfStatement', test, consequent, alternate };
+  return { 
+    type: 'IfStatement', 
+    test, 
+    consequent, 
+    alternate, 
+    line: t.line, 
+    column: t.column 
+  };
 }
 
 whileStatement() {
+  const t = this.current; // WHILE token
   this.eat('WHILE');
 
   let test;
@@ -179,10 +251,17 @@ whileStatement() {
   }
 
   const body = this.block();
-  return { type: 'WhileStatement', test, body };
+  return { 
+    type: 'WhileStatement', 
+    test, 
+    body, 
+    line: t.line, 
+    column: t.column 
+  };
 }
 
 importStatement() {
+  const t = this.current; // IMPORT token
   this.eat('IMPORT');
 
   let specifiers = [];
@@ -191,11 +270,13 @@ importStatement() {
     this.eat('AS');
     const name = this.current.value;
     this.eat('IDENTIFIER');
-    specifiers.push({ type: 'NamespaceImport', local: name });
+    specifiers.push({ type: 'NamespaceImport', local: name, line: t.line, column: t.column });
   } else if (this.current.type === 'LBRACE') {
     this.eat('LBRACE');
     while (this.current.type !== 'RBRACE') {
       const importedName = this.current.value;
+      const importedLine = this.current.line;
+      const importedColumn = this.current.column;
       this.eat('IDENTIFIER');
 
       let localName = importedName;
@@ -205,14 +286,16 @@ importStatement() {
         this.eat('IDENTIFIER');
       }
 
-      specifiers.push({ type: 'NamedImport', imported: importedName, local: localName });
+      specifiers.push({ type: 'NamedImport', imported: importedName, local: localName, line: importedLine, column: importedColumn });
       if (this.current.type === 'COMMA') this.eat('COMMA');
     }
     this.eat('RBRACE');
   } else if (this.current.type === 'IDENTIFIER') {
     const localName = this.current.value;
+    const localLine = this.current.line;
+    const localColumn = this.current.column;
     this.eat('IDENTIFIER');
-    specifiers.push({ type: 'DefaultImport', local: localName });
+    specifiers.push({ type: 'DefaultImport', local: localName, line: localLine, column: localColumn });
   } else {
     throw new Error(`Unexpected token in import at line ${this.current.line}, column ${this.current.column}`);
   }
@@ -224,9 +307,17 @@ importStatement() {
 
   if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
 
-  return { type: 'ImportStatement', path: pathToken.value, specifiers };
+  return { 
+    type: 'ImportStatement', 
+    path: pathToken.value, 
+    specifiers, 
+    line: t.line, 
+    column: t.column 
+  };
 }
+
 forStatement() {
+  const t = this.current; // FOR token
   this.eat('FOR');
 
   // --- Python-style: for variable in iterable (supports optional 'let') ---
@@ -234,17 +325,22 @@ forStatement() {
       (this.current.type === 'IDENTIFIER' && this.peekType() === 'IN')) {
 
     let variable;
+    let variableLine, variableColumn;
     let iterable;
     let letKeyword = false;
 
     if (this.current.type === 'LET') {
       letKeyword = true;
       this.eat('LET');
+      variableLine = this.current.line;
+      variableColumn = this.current.column;
       variable = this.current.value;
       this.eat('IDENTIFIER');
       this.eat('IN');
       iterable = this.expression();
     } else {
+      variableLine = this.current.line;
+      variableColumn = this.current.column;
       variable = this.current.value;
       this.eat('IDENTIFIER');
       this.eat('IN');
@@ -252,7 +348,17 @@ forStatement() {
     }
 
     const body = this.block();
-    return { type: 'ForInStatement', variable, iterable, letKeyword, body };
+    return { 
+      type: 'ForInStatement', 
+      variable, 
+      variableLine, 
+      variableColumn,
+      iterable, 
+      letKeyword, 
+      body,
+      line: t.line,
+      column: t.column
+    };
   }
 
   // --- C-style: for(init; test; update) ---
@@ -287,37 +393,51 @@ forStatement() {
   }
 
   const body = this.block();
-  return { type: 'ForStatement', init, test, update, body };
+  return { 
+    type: 'ForStatement', 
+    init, 
+    test, 
+    update, 
+    body,
+    line: t.line,
+    column: t.column
+  };
 }
 
 breakStatement() {
+  const t = this.current; // BREAK token
   this.eat('BREAK');
   // Python-style: no semicolon needed, ignore if present
   if (this.current.type === 'SEMICOLON') this.advance();
-  return { type: 'BreakStatement' };
+  return { type: 'BreakStatement', line: t.line, column: t.column };
 }
 
 continueStatement() {
+  const t = this.current; // CONTINUE token
   this.eat('CONTINUE');
   // Python-style: no semicolon needed, ignore if present
   if (this.current.type === 'SEMICOLON') this.advance();
-  return { type: 'ContinueStatement' };
+  return { type: 'ContinueStatement', line: t.line, column: t.column };
 }
 
 funcDeclaration() {
+  const t = this.current; // FUNC token
   this.eat('FUNC');
-  const name = this.current.value;
+  const nameToken = this.current;
+  const name = nameToken.value;
   this.eat('IDENTIFIER');
 
   let params = [];
   if (this.current.type === 'LPAREN') {
     this.eat('LPAREN');
     if (this.current.type !== 'RPAREN') {
-      params.push(this.current.value);
+      const paramToken = this.current;
+      params.push({ name: paramToken.value, line: paramToken.line, column: paramToken.column });
       this.eat('IDENTIFIER');
       while (this.current.type === 'COMMA') {
         this.eat('COMMA');
-        params.push(this.current.value);
+        const paramToken2 = this.current;
+        params.push({ name: paramToken2.value, line: paramToken2.line, column: paramToken2.column });
         this.eat('IDENTIFIER');
       }
     }
@@ -325,16 +445,18 @@ funcDeclaration() {
   } else {
     // Python-style: single param without parentheses
     if (this.current.type === 'IDENTIFIER') {
-      params.push(this.current.value);
+      const paramToken = this.current;
+      params.push({ name: paramToken.value, line: paramToken.line, column: paramToken.column });
       this.eat('IDENTIFIER');
     }
   }
 
   const body = this.block();
-  return { type: 'FunctionDeclaration', name, params, body };
+  return { type: 'FunctionDeclaration', name, params, body, line: t.line, column: t.column };
 }
 
 returnStatement() {
+  const t = this.current; // RETURN token
   this.eat('RETURN');
 
   let argument = null;
@@ -345,24 +467,26 @@ returnStatement() {
   // semicolon optional
   if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
 
-  return { type: 'ReturnStatement', argument };
+  return { type: 'ReturnStatement', argument, line: t.line, column: t.column };
 }
 
 block() {
+  const t = this.current; // LBRACE token
   this.eat('LBRACE');
   const body = [];
   while (this.current.type !== 'RBRACE') {
     body.push(this.statement());
   }
   this.eat('RBRACE');
-  return { type: 'BlockStatement', body };
+  return { type: 'BlockStatement', body, line: t.line, column: t.column };
 }
 
 expressionStatement() {
+  const exprToken = this.current; // first token of the expression
   const expr = this.expression();
   // semicolon optional
   if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
-  return { type: 'ExpressionStatement', expression: expr };
+  return { type: 'ExpressionStatement', expression: expr, line: exprToken.line, column: exprToken.column };
 }
 
 expression() {
@@ -373,17 +497,19 @@ assignment() {
   const node = this.logicalOr();
   const compoundOps = ['PLUSEQ', 'MINUSEQ', 'STAREQ', 'SLASHEQ', 'MODEQ'];
 
-  if (compoundOps.includes(this.current.type)) {
-    const op = this.current.type;
+  const t = this.current;
+
+  if (compoundOps.includes(t.type)) {
+    const op = t.type;
     this.eat(op);
     const right = this.assignment();
-    return { type: 'CompoundAssignment', operator: op, left: node, right };
+    return { type: 'CompoundAssignment', operator: op, left: node, right, line: t.line, column: t.column };
   }
 
-  if (this.current.type === 'EQUAL') {
+  if (t.type === 'EQUAL') {
     this.eat('EQUAL');
     const right = this.assignment();
-    return { type: 'AssignmentExpression', left: node, right };
+    return { type: 'AssignmentExpression', left: node, right, line: t.line, column: t.column };
   }
 
   return node;
@@ -392,9 +518,10 @@ assignment() {
 logicalOr() {
   let node = this.logicalAnd();
   while (this.current.type === 'OR') {
-    const op = this.current.type;
+    const t = this.current;
+    const op = t.type;
     this.eat(op);
-    node = { type: 'LogicalExpression', operator: op, left: node, right: this.logicalAnd() };
+    node = { type: 'LogicalExpression', operator: op, left: node, right: this.logicalAnd(), line: t.line, column: t.column };
   }
   return node;
 }
@@ -402,18 +529,21 @@ logicalOr() {
 logicalAnd() {
   let node = this.equality();
   while (this.current.type === 'AND') {
-    const op = this.current.type;
+    const t = this.current;
+    const op = t.type;
     this.eat(op);
-    node = { type: 'LogicalExpression', operator: op, left: node, right: this.equality() };
+    node = { type: 'LogicalExpression', operator: op, left: node, right: this.equality(), line: t.line, column: t.column };
   }
   return node;
 }
+
 equality() {
   let node = this.comparison();
   while (['EQEQ', 'NOTEQ'].includes(this.current.type)) {
-    const op = this.current.type;
+    const t = this.current;
+    const op = t.type;
     this.eat(op);
-    node = { type: 'BinaryExpression', operator: op, left: node, right: this.comparison() };
+    node = { type: 'BinaryExpression', operator: op, left: node, right: this.comparison(), line: t.line, column: t.column };
   }
   return node;
 }
@@ -421,9 +551,10 @@ equality() {
 comparison() {
   let node = this.term();
   while (['LT', 'LTE', 'GT', 'GTE'].includes(this.current.type)) {
-    const op = this.current.type;
+    const t = this.current;
+    const op = t.type;
     this.eat(op);
-    node = { type: 'BinaryExpression', operator: op, left: node, right: this.term() };
+    node = { type: 'BinaryExpression', operator: op, left: node, right: this.term(), line: t.line, column: t.column };
   }
   return node;
 }
@@ -431,9 +562,10 @@ comparison() {
 term() {
   let node = this.factor();
   while (['PLUS', 'MINUS'].includes(this.current.type)) {
-    const op = this.current.type;
+    const t = this.current;
+    const op = t.type;
     this.eat(op);
-    node = { type: 'BinaryExpression', operator: op, left: node, right: this.factor() };
+    node = { type: 'BinaryExpression', operator: op, left: node, right: this.factor(), line: t.line, column: t.column };
   }
   return node;
 }
@@ -441,26 +573,43 @@ term() {
 factor() {
   let node = this.unary();
   while (['STAR', 'SLASH', 'MOD'].includes(this.current.type)) {
-    const op = this.current.type;
+    const t = this.current;
+    const op = t.type;
     this.eat(op);
-    node = { type: 'BinaryExpression', operator: op, left: node, right: this.unary() };
+    node = { type: 'BinaryExpression', operator: op, left: node, right: this.unary(), line: t.line, column: t.column };
   }
   return node;
 }
 
+
 unary() {
-  if (['NOT', 'MINUS', 'PLUS'].includes(this.current.type)) {
-    const op = this.current.type;
+  const t = this.current;
+
+  if (['NOT', 'MINUS', 'PLUS'].includes(t.type)) {
+    const op = t.type;
     this.eat(op);
-    return { type: 'UnaryExpression', operator: op, argument: this.unary() };
+    return {
+      type: 'UnaryExpression',
+      operator: op,
+      argument: this.unary(),
+      line: t.line,
+      column: t.column
+    };
   }
 
   // Python-like: ignore ++ and -- if not used
-  if (this.current.type === 'PLUSPLUS' || this.current.type === 'MINUSMINUS') {
-    const op = this.current.type;
+  if (t.type === 'PLUSPLUS' || t.type === 'MINUSMINUS') {
+    const op = t.type;
     this.eat(op);
     const argument = this.unary();
-    return { type: 'UpdateExpression', operator: op, argument, prefix: true };
+    return {
+      type: 'UpdateExpression',
+      operator: op,
+      argument,
+      prefix: true,
+      line: t.line,
+      column: t.column
+    };
   }
 
   return this.postfix();
@@ -469,15 +618,21 @@ unary() {
 postfix() {
   let node = this.primary();
   while (true) {
-    if (this.current.type === 'LBRACKET') {
+    const t = this.current;
+
+    if (t.type === 'LBRACKET') {
+      const startLine = t.line;
+      const startCol = t.column;
       this.eat('LBRACKET');
       const index = this.expression();
       if (this.current.type === 'RBRACKET') this.eat('RBRACKET');
-      node = { type: 'IndexExpression', object: node, indexer: index };
+      node = { type: 'IndexExpression', object: node, indexer: index, line: startLine, column: startCol };
       continue;
     }
 
-    if (this.current.type === 'LPAREN') {
+    if (t.type === 'LPAREN') {
+      const startLine = t.line;
+      const startCol = t.column;
       this.eat('LPAREN');
       const args = [];
       while (this.current.type !== 'RPAREN' && this.current.type !== 'EOF') {
@@ -485,30 +640,30 @@ postfix() {
         if (this.current.type === 'COMMA') this.eat('COMMA'); // optional comma
       }
       if (this.current.type === 'RPAREN') this.eat('RPAREN');
-      node = { type: 'CallExpression', callee: node, arguments: args };
+      node = { type: 'CallExpression', callee: node, arguments: args, line: startLine, column: startCol };
       continue;
     }
 
-    if (this.current.type === 'DOT') {
+    if (t.type === 'DOT') {
+      const startLine = t.line;
+      const startCol = t.column;
       this.eat('DOT');
       const property = this.current.value || '';
       if (this.current.type === 'IDENTIFIER') this.eat('IDENTIFIER');
-      node = { type: 'MemberExpression', object: node, property };
+      node = { type: 'MemberExpression', object: node, property, line: startLine, column: startCol };
       continue;
     }
 
-    if (this.current.type === 'PLUSPLUS' || this.current.type === 'MINUSMINUS') {
-      const op = this.current.type;
-      this.eat(op);
-      node = { type: 'UpdateExpression', operator: op, argument: node, prefix: false };
+    if (t.type === 'PLUSPLUS' || t.type === 'MINUSMINUS') {
+      this.eat(t.type);
+      node = { type: 'UpdateExpression', operator: t.type, argument: node, prefix: false, line: t.line, column: t.column };
       continue;
     }
 
-    // Python-style: implicit function calls (if identifier followed by identifier)
-    if (node.type === 'Identifier' && this.current.type === 'IDENTIFIER') {
-      const argNode = { type: 'Identifier', name: this.current.value };
+    if (node.type === 'Identifier' && t.type === 'IDENTIFIER') {
+      const argNode = { type: 'Identifier', name: t.value, line: t.line, column: t.column };
       this.eat('IDENTIFIER');
-      node = { type: 'CallExpression', callee: node, arguments: [argNode] };
+      node = { type: 'CallExpression', callee: node, arguments: [argNode], line: node.line, column: node.column };
       continue;
     }
 
@@ -518,12 +673,18 @@ postfix() {
 }
 
 arrowFunction(params) {
-  if (this.current.type === 'ARROW') this.eat('ARROW');
+  const t = this.current;
+  if (t.type === 'ARROW') this.eat('ARROW');
   const body = this.expression();
+  const startLine = params.length > 0 ? params[0].line : t.line;
+  const startCol = params.length > 0 ? params[0].column : t.column;
+
   return {
     type: 'ArrowFunctionExpression',
     params,
-    body
+    body,
+    line: startLine,
+    column: startCol
   };
 }
 
@@ -531,16 +692,35 @@ arrowFunction(params) {
   primary() {
   const t = this.current;
 
-  if (t.type === 'NUMBER') { this.eat('NUMBER'); return { type: 'Literal', value: t.value }; }
-  if (t.type === 'STRING') { this.eat('STRING'); return { type: 'Literal', value: t.value }; }
-  if (t.type === 'TRUE') { this.eat('TRUE'); return { type: 'Literal', value: true }; }
-  if (t.type === 'FALSE') { this.eat('FALSE'); return { type: 'Literal', value: false }; }
-  if (t.type === 'NULL') { this.eat('NULL'); return { type: 'Literal', value: null }; }
+  if (t.type === 'NUMBER') { 
+    this.eat('NUMBER'); 
+    return { type: 'Literal', value: t.value, line: t.line, column: t.column }; 
+  }
+
+  if (t.type === 'STRING') { 
+    this.eat('STRING'); 
+    return { type: 'Literal', value: t.value, line: t.line, column: t.column }; 
+  }
+
+  if (t.type === 'TRUE') { 
+    this.eat('TRUE'); 
+    return { type: 'Literal', value: true, line: t.line, column: t.column }; 
+  }
+
+  if (t.type === 'FALSE') { 
+    this.eat('FALSE'); 
+    return { type: 'Literal', value: false, line: t.line, column: t.column }; 
+  }
+
+  if (t.type === 'NULL') { 
+    this.eat('NULL'); 
+    return { type: 'Literal', value: null, line: t.line, column: t.column }; 
+  }
 
   if (t.type === 'AWAIT') {
     this.eat('AWAIT');
     const argument = this.expression(); 
-    return { type: 'AwaitExpression', argument };
+    return { type: 'AwaitExpression', argument, line: t.line, column: t.column };
   }
 
   if (t.type === 'NEW') {
@@ -556,7 +736,7 @@ arrowFunction(params) {
       }
     }
     this.eat('RPAREN');
-    return { type: 'NewExpression', callee, arguments: args };
+    return { type: 'NewExpression', callee, arguments: args, line: t.line, column: t.column };
   }
 
   if (t.type === 'ASK') {
@@ -571,7 +751,13 @@ arrowFunction(params) {
       }
     }
     this.eat('RPAREN');
-    return { type: 'CallExpression', callee: { type: 'Identifier', name: 'ask' }, arguments: args };
+    return { 
+      type: 'CallExpression', 
+      callee: { type: 'Identifier', name: 'ask', line: t.line, column: t.column }, 
+      arguments: args, 
+      line: t.line, 
+      column: t.column 
+    };
   }
 
   if (t.type === 'IDENTIFIER') {
@@ -579,13 +765,15 @@ arrowFunction(params) {
     this.eat('IDENTIFIER');
 
     if (this.current.type === 'ARROW') {
-      return this.arrowFunction([name]);
+      return this.arrowFunction([{ type: 'Identifier', name, line: t.line, column: t.column }]);
     }
 
-    return { type: 'Identifier', name };
+    return { type: 'Identifier', name, line: t.line, column: t.column };
   }
 
   if (t.type === 'LPAREN') {
+    const startLine = t.line;
+    const startCol = t.column;
     this.eat('LPAREN');
     const elements = [];
 
@@ -601,10 +789,12 @@ arrowFunction(params) {
 
     if (this.current.type === 'ARROW') return this.arrowFunction(elements);
 
-    return elements.length === 1 ? elements[0] : { type: 'ArrayExpression', elements };
+    return elements.length === 1 ? elements[0] : { type: 'ArrayExpression', elements, line: startLine, column: startCol };
   }
 
   if (t.type === 'LBRACKET') {
+    const startLine = t.line;
+    const startCol = t.column;
     this.eat('LBRACKET');
     const elements = [];
     if (this.current.type !== 'RBRACKET') {
@@ -615,10 +805,12 @@ arrowFunction(params) {
       }
     }
     this.eat('RBRACKET');
-    return { type: 'ArrayExpression', elements };
+    return { type: 'ArrayExpression', elements, line: startLine, column: startCol };
   }
 
   if (t.type === 'LBRACE') {
+    const startLine = t.line;
+    const startCol = t.column;
     this.eat('LBRACE');
     const props = [];
     while (this.current.type !== 'RBRACE') {
@@ -629,12 +821,17 @@ arrowFunction(params) {
       if (this.current.type === 'COMMA') this.eat('COMMA'); // optional trailing comma
     }
     this.eat('RBRACE');
-    return { type: 'ObjectExpression', props };
+    return { type: 'ObjectExpression', props, line: startLine, column: startCol };
   }
 
-  throw new Error(`Unexpected token in primary: ${t.type} at line ${this.current.line}, column ${this.current.column}`);
+  throw new ParseError(
+    `Unexpected token '${t.type}'`,
+    t,
+    this.source
+  );
 }
 
+
 }
 
 module.exports = Parser;