exprify 1.0.4 → 1.0.6

package/src/parser/astBuild.js

@@ -1,16 +1,45 @@
+/** @param {string | any[]} tokens */
 export function buildAST(tokens) {
   let current = 0;
 
   const peek = () => tokens[current];
   const consume = () => tokens[current++];
+  const lastPos = () => {
+    const t = current > 0 ? tokens[current - 1] : null;
+    return t && t.pos !== undefined ? t.pos : -1;
+  };
+  const tokenPos = () => {
+    const t = peek();
+    return t && t.pos !== undefined ? t.pos : -1;
+  };
+
+  const nodeAt = (/** @type {any} */ node) => {
+    const pos = lastPos();
+    if (pos >= 0) {
+      node.pos = pos;
+    }
+    return node;
+  };
+
+  const syntaxError = (/** @type {string} */ msg) => {
+    const pos = tokenPos() >= 0 ? tokenPos() : lastPos();
+    const at = pos >= 0 ? ` at position ${pos}` : '';
+    throw new Error(`${msg}${at}`);
+  };
 
-  const match = (type, value) => {
+  const match = (/** @type {string} */ type, /** @type {string | undefined} */ value) => {
     const t = peek();
-    if (!t) return false;
+    if (!t) {
+      return false;
+    }
 
-    if (t.type !== type) return false;
+    if (t.type !== type) {
+      return false;
+    }
 
-    if (value !== undefined && t.value !== value) return false;
+    if (value !== undefined && t.value !== value) {
+      return false;
+    }
 
     current++;
     return true;
@@ -19,203 +48,208 @@ export function buildAST(tokens) {
   const parseSliceOrIndex = () => {
     let start = null;
 
-    if (!(peek()?.type === "Colon" || peek()?.type === "Comma" || peek()?.type === "ArrayEnd")) {
+    if (!(peek()?.type === 'Colon' || peek()?.type === 'Comma' || peek()?.type === 'ArrayEnd')) {
       start = parseExpression();
     }
 
-    if (match("Colon")) {
+    if (match('Colon', undefined)) {
       let end = null;
 
-      if (!(peek()?.type === "Comma" || peek()?.type === "ArrayEnd")) {
+      if (!(peek()?.type === 'Comma' || peek()?.type === 'ArrayEnd')) {
         end = parseExpression();
       }
 
       return {
-        type: "SliceExpression",
+        type: 'SliceExpression',
         start,
-        end
+        end,
       };
     }
 
     return start;
   };
 
-  /* ================= PRIMARY ================= */
   function parsePrimary() {
     const token = consume();
-    if (!token) throw new Error("Unexpected end of input");
+    if (!token) {
+      syntaxError('Unexpected end of input');
+    }
+
+    const withPos = (/** @type {any} */ node) => {
+      if (token.pos !== undefined) {
+        node.pos = token.pos;
+      }
+      return node;
+    };
 
     switch (token.type) {
-      case "Number":
-      case "BigInt":
-      case "Boolean":
-      case "String":
-        return { type: "Literal", value: token.value };
-
-      case "ImaginaryLiteral":
-        return { type: "ImaginaryLiteral", value: token.value };
-
-      case "NumberWithUnit":
-        return {
-          type: "UnitLiteral",
+      case 'Number':
+      case 'BigInt':
+      case 'Boolean':
+      case 'String':
+        return withPos({ type: 'Literal', value: token.value });
+
+      case 'ImaginaryLiteral':
+        return withPos({ type: 'ImaginaryLiteral', value: token.value });
+
+      case 'NumberWithUnit':
+        return withPos({
+          type: 'UnitLiteral',
           value: token.value,
-          unit: token.unit
-        };
-
-      case "Identifier":
-        return { type: "Identifier", name: token.name };
-      
-      case "Function":
-        return {
-          type: "Identifier",
-          name: token.name
-        };
-
-      case "Parenthesis":
-        if (token.value === "(") {
+          unit: token.unit,
+        });
+
+      case 'Identifier':
+        return withPos({ type: 'Identifier', name: token.name });
+
+      case 'Function':
+        return withPos({
+          type: 'Identifier',
+          name: token.name,
+        });
+
+      case 'Parenthesis':
+        if (token.value === '(') {
           const expr = parseExpression();
 
-          if (!match("Parenthesis", ")")) {
-            throw new Error(`Expected ')'`);
+          if (!match('Parenthesis', ')')) {
+            syntaxError("Expected ')'");
           }
 
           return expr;
         }
-        
-      case "ArrayStart": {
+
+      // falls through
+
+      case 'ArrayStart': {
         const rows = [];
         let currentRow = [];
 
-        if (!match("ArrayEnd")) {
+        if (!match('ArrayEnd', undefined)) {
           while (true) {
             currentRow.push(parseExpression());
 
-            if (match("Comma")) {
+            if (match('Comma', undefined)) {
               continue;
             }
 
-            if (match("Semicolon")) {
+            if (match('Semicolon', undefined)) {
               rows.push(currentRow);
               currentRow = [];
               continue;
             }
 
-            if (match("ArrayEnd")) {
+            if (match('ArrayEnd', undefined)) {
               rows.push(currentRow);
               break;
             }
 
-            throw new Error(`Expected ',', ';', or ']' at ${current}`);
+            syntaxError("Expected ',', ';', or ']'");
           }
         }
 
         if (!rows.length) {
-          return { type: "ArrayExpression", elements: [] };
+          return withPos({ type: 'ArrayExpression', elements: [] });
         }
 
         if (rows.length === 1) {
-          return { type: "ArrayExpression", elements: rows[0] };
+          return withPos({ type: 'ArrayExpression', elements: rows[0] });
         }
 
-        return {
-          type: "ArrayExpression",
+        return withPos({
+          type: 'ArrayExpression',
           elements: rows.map((elements) => ({
-            type: "ArrayExpression",
-            elements
-          }))
-        };
+            type: 'ArrayExpression',
+            elements,
+          })),
+        });
       }
 
-      case "BlockStart": {
+      case 'BlockStart': {
         const properties = [];
 
-        if (!match("BlockEnd")) {
+        if (!match('BlockEnd', undefined)) {
           do {
             const keyToken = consume();
 
-            if (
-              keyToken.type !== "Identifier" &&
-              keyToken.type !== "String"
-            ) {
-              throw new Error("Invalid object key");
+            if (keyToken.type !== 'Identifier' && keyToken.type !== 'String') {
+              syntaxError('Invalid object key');
             }
 
-            if (!match("Colon")) {
-              throw new Error("Expected ':' after key");
+            if (!match('Colon', undefined)) {
+              syntaxError("Expected ':' after key");
             }
 
             const value = parseExpression();
 
             properties.push({
               key: keyToken.value,
-              value
+              value,
             });
+          } while (match('Comma', undefined));
 
-          } while (match("Comma"));
-
-          if (!match("BlockEnd")) {
-            throw new Error(`Expected '}' at ${current}`);
+          if (!match('BlockEnd', undefined)) {
+            syntaxError("Expected '}'");
           }
         }
 
-        return { type: "ObjectExpression", properties };
+        return withPos({ type: 'ObjectExpression', properties });
       }
     }
 
-    throw new Error(`Unexpected token: ${JSON.stringify(token)}`);
+    syntaxError(`Unexpected token: ${JSON.stringify(token.value || token.name || token.type)}`);
   }
 
-  /* ================= MEMBER ================= */
   function parseMember() {
     let object = parsePrimary();
 
     while (true) {
-      if (match("ArrayStart")) {
+      if (match('ArrayStart', undefined)) {
         const selectors = [];
 
-        if (!match("ArrayEnd")) {
+        if (!match('ArrayEnd', undefined)) {
           do {
             selectors.push(parseSliceOrIndex());
-          } while (match("Comma"));
+          } while (match('Comma', undefined));
 
-          if (!match("ArrayEnd")) {
-            throw new Error(`Expected ']' at ${current}`);
+          if (!match('ArrayEnd', undefined)) {
+            syntaxError("Expected ']'");
           }
         }
 
-        object = {
-          type: "IndexExpression",
+        object = nodeAt({
+          type: 'IndexExpression',
           object,
-          selectors
-        };
+          selectors,
+        });
         continue;
       }
 
-      if (match("Dot")) {
+      if (match('Dot', undefined)) {
         const property = consume();
 
-        if (property.type !== "Identifier") {
-          throw new Error("Expected property after '.'");
+        if (property.type !== 'Identifier') {
+          syntaxError("Expected property after '.'");
         }
 
-        object = {
-          type: "MemberExpression",
+        object = nodeAt({
+          type: 'MemberExpression',
           object,
-          property: { type: "Identifier", name: property.value },
-          optional: false
-        };
+          property: { type: 'Identifier', name: property.value },
+          optional: false,
+        });
         continue;
       }
 
-      if (match("Operator", "?.")) {
+      if (match('Operator', '?.')) {
         const property = consume();
 
-        object = {
-          type: "MemberExpression",
+        object = nodeAt({
+          type: 'MemberExpression',
           object,
-          property: { type: "Identifier", name: property.value },
-          optional: true
-        };
+          property: { type: 'Identifier', name: property.value },
+          optional: true,
+        });
         continue;
       }
 
@@ -225,296 +259,322 @@ export function buildAST(tokens) {
     return object;
   }
 
-  /* ================= CALL ================= */
   function parseCallChain() {
     let expr = parseMember();
 
-    while (peek()?.type === "Parenthesis" && peek()?.value === "(") {
-      consume(); // '('
+    while (peek()?.type === 'Parenthesis' && peek()?.value === '(') {
+      consume();
 
       const args = [];
 
-      if (!(peek()?.type === "Parenthesis" && peek()?.value === ")")) {
+      if (!(peek()?.type === 'Parenthesis' && peek()?.value === ')')) {
         do {
-          args.push(parseExpression());
-        } while (match("Comma"));
+          if (match('Spread', undefined)) {
+            const arg = parseExpression();
+            args.push({ type: 'SpreadElement', argument: arg });
+          } else {
+            args.push(parseExpression());
+          }
+        } while (match('Comma', undefined));
       }
 
-      if (!match("Parenthesis", ")")) {
-        throw new Error(`Expected ')' at ${current}`);
+      if (!match('Parenthesis', ')')) {
+        syntaxError("Expected ')'");
       }
 
-      expr = {
-        type: "CallExpression",
+      expr = nodeAt({
+        type: 'CallExpression',
         callee: expr,
-        arguments: args
-      };
+        arguments: args,
+      });
     }
 
     return expr;
   }
 
-  /* ================= UNARY ================= */
   function parseUnary() {
-    if (match("UnaryOperator")) {
+    if (match('UnaryOperator', undefined)) {
       const operator = tokens[current - 1].value;
 
-      return {
-        type: "UnaryExpression",
+      return nodeAt({
+        type: 'UnaryExpression',
         operator,
-        argument: parseUnary()
-      };
+        argument: parseUnary(),
+      });
     }
 
     return parseCallChain();
   }
 
-  /* ================= POWER ================= */
   function parsePower() {
-    let left = parseUnary();
+    const left = parseUnary();
 
-    if (match("Operator", "^")) {
+    if (match('Operator', '^')) {
       const right = parsePower();
-      return {
-        type: "BinaryExpression",
-        operator: "^",
+      return nodeAt({
+        type: 'BinaryExpression',
+        operator: '^',
         left,
-        right
-      };
+        right,
+      });
     }
 
     return left;
   }
 
-  /* ================= MULT ================= */
   function parseMultiplication() {
     let left = parsePower();
 
-    while (
-      match("Operator", "*") ||
-      match("Operator", "/") ||
-      match("Operator", "%")
-    ) {
+    while (match('Operator', '*') || match('Operator', '/') || match('Operator', '%')) {
       const operator = tokens[current - 1].value;
       const right = parsePower();
 
-      left = {
-        type: "BinaryExpression",
+      left = nodeAt({
+        type: 'BinaryExpression',
         operator,
         left,
-        right
-      };
+        right,
+      });
     }
 
     return left;
   }
 
-  /* ================= ADD ================= */
   function parseAddition() {
     let left = parseMultiplication();
 
-    while (match("Operator", "+") || match("Operator", "-")) {
+    while (match('Operator', '+') || match('Operator', '-')) {
       const operator = tokens[current - 1].value;
       const right = parseMultiplication();
 
-      left = {
-        type: "BinaryExpression",
+      left = nodeAt({
+        type: 'BinaryExpression',
         operator,
         left,
-        right
-      };
+        right,
+      });
     }
 
     return left;
   }
 
-  /* ================= UNIT CONVERSION ================= */
   function parseUnitConversion() {
-    let left = parseAddition();
+    const left = parseAddition();
 
     const nextKeyword = peek();
-    if (nextKeyword?.type === "Keyword" && ["to", "in"].includes(nextKeyword.value)) {
+    if (nextKeyword?.type === 'Keyword' && ['to', 'in'].includes(nextKeyword.value)) {
       consume();
       const next = consume();
 
-      if (!next || next.type !== "Unit") {
-        throw new Error(`Expected unit after '${nextKeyword.value}'`);
+      if (!next || next.type !== 'Unit') {
+        syntaxError(`Expected unit after '${nextKeyword.value}'`);
       }
 
-      return {
-        type: "UnitConversion",
+      return nodeAt({
+        type: 'UnitConversion',
         from: left,
-        to: next.value
-      };
+        to: next.value,
+      });
     }
 
     return left;
   }
 
-  /* ================= COMPARISON ================= */
   function parseComparison() {
     let left = parseUnitConversion();
 
     while (
-      match("Operator", ">") ||
-      match("Operator", "<") ||
-      match("Operator", ">=") ||
-      match("Operator", "<=") ||
-      match("Operator", "==")
+      match('Operator', '>') ||
+      match('Operator', '<') ||
+      match('Operator', '>=') ||
+      match('Operator', '<=') ||
+      match('Operator', '==')
     ) {
       const operator = tokens[current - 1].value;
       const right = parseUnitConversion();
 
-      left = {
-        type: "BinaryExpression",
+      left = nodeAt({
+        type: 'BinaryExpression',
         operator,
         left,
-        right
-      };
+        right,
+      });
     }
 
     return left;
   }
 
-  /* ================= LOGICAL ================= */
   function parseLogical() {
     let left = parseComparison();
 
-    while (
-      match("Operator", "&&") ||
-      match("Operator", "||")
-    ) {
+    while (match('Operator', '&&') || match('Operator', '||')) {
       const operator = tokens[current - 1].value;
       const right = parseComparison();
 
-      left = {
-        type: "LogicalExpression",
+      left = nodeAt({
+        type: 'LogicalExpression',
         operator,
         left,
-        right
-      };
+        right,
+      });
     }
 
     return left;
   }
 
-  /* ================= NULLISH ================= */
   function parseNullish() {
     let left = parseLogical();
 
-    while (match("Operator", "??")) {
+    while (match('Operator', '??')) {
       const right = parseLogical();
 
-      left = {
-        type: "LogicalExpression",
-        operator: "??",
+      left = nodeAt({
+        type: 'LogicalExpression',
+        operator: '??',
         left,
-        right
-      };
+        right,
+      });
     }
 
     return left;
   }
 
-  /* ================= TERNARY ================= */
   function parseTernary() {
-    let test = parseNullish();
+    const test = parseNullish();
 
-    if (match("Ternary", "?")) {
+    if (match('Ternary', '?')) {
       const consequent = parseExpression();
 
-      if (!match("Ternary", ":")) {
-        throw new Error("Expected ':' in ternary");
+      if (!match('Ternary', ':')) {
+        syntaxError("Expected ':' in ternary");
       }
 
       const alternate = parseExpression();
 
-      return {
-        type: "ConditionalExpression",
+      return nodeAt({
+        type: 'ConditionalExpression',
         test,
         consequent,
-        alternate
-      };
+        alternate,
+      });
+    }
+
+    if (match('Colon', undefined)) {
+      const end = parseNullish();
+
+      return nodeAt({
+        type: 'RangeExpression',
+        start: test,
+        end,
+      });
     }
 
     return test;
   }
 
-  /* ================= PIPELINE ================= */
+  function parseLambda() {
+    const left = parsePipeline();
+
+    if (match('Operator', '->')) {
+      let params;
+      if (left.type === 'Identifier') {
+        params = [left.name];
+      } else if (left.type === 'ArrayExpression') {
+        params = left.elements.map((/** @type {{ type: string; name: any; }} */ el) => {
+          if (el.type !== 'Identifier') {
+            syntaxError('Lambda parameter must be an identifier');
+          }
+          return el.name;
+        });
+      } else {
+        syntaxError('Invalid lambda parameter');
+      }
+
+      const body = parseLambda();
+
+      return nodeAt({
+        type: 'ArrowFunctionExpression',
+        params,
+        body,
+      });
+    }
+
+    return left;
+  }
+
   function parsePipeline() {
     let left = parseTernary();
 
-    while (match("Operator", "|>")) {
+    while (match('Operator', '|>')) {
       const right = parseTernary();
 
-      left = {
-        type: "PipelineExpression",
+      left = nodeAt({
+        type: 'PipelineExpression',
         left,
-        right
-      };
+        right,
+      });
     }
 
     return left;
   }
 
-  /* ================= ASSIGNMENT ================= */
   function parseAssignment() {
-    let left = parsePipeline();
+    const left = parseLambda();
 
     if (
-      match("Operator", "=") ||
-      match("Operator", "+=") ||
-      match("Operator", "-=") ||
-      match("Operator", "*=") ||
-      match("Operator", "/=")
+      match('Operator', '=') ||
+      match('Operator', '+=') ||
+      match('Operator', '-=') ||
+      match('Operator', '*=') ||
+      match('Operator', '/=')
     ) {
       const operator = tokens[current - 1].value;
 
-      if (left.type === "CallExpression") {
+      // f(a,b) = expr: treat as function definition, not assignment
+      if (left.type === 'CallExpression') {
         const isFunctionTarget =
-          left.callee?.type === "Identifier" &&
-          left.arguments.every((arg) => arg.type === "Identifier");
+          left.callee?.type === 'Identifier' &&
+          left.arguments.every((/** @type {{ type: string; }} */ arg) => arg.type === 'Identifier');
 
         if (!isFunctionTarget) {
-          throw new Error("Invalid function definition");
+          syntaxError('Invalid function definition');
         }
 
         const right = parseAssignment();
 
-        return {
-          type: "FunctionAssignmentExpression",
+        return nodeAt({
+          type: 'FunctionAssignmentExpression',
           operator,
           left: {
-            type: "Identifier",
-            name: left.callee.name
+            type: 'Identifier',
+            name: left.callee.name,
           },
-          params: left.arguments.map((arg) => arg.name),
-          right
-        };
+          params: left.arguments.map((/** @type {{ name: any; }} */ arg) => arg.name),
+          right,
+        });
       }
 
       if (
-        left.type !== "Identifier" &&
-        left.type !== "MemberExpression" &&
-        left.type !== "IndexExpression"
+        left.type !== 'Identifier' &&
+        left.type !== 'MemberExpression' &&
+        left.type !== 'IndexExpression'
       ) {
-        throw new Error("Invalid assignment target");
+        syntaxError('Invalid assignment target');
       }
 
       const right = parseAssignment();
 
-      return {
-        type: "AssignmentExpression",
+      return nodeAt({
+        type: 'AssignmentExpression',
         operator,
         left,
-        right
-      };
+        right,
+      });
     }
 
     return left;
   }
 
-  /* ================= ENTRY ================= */
   function parseExpression() {
     return parseAssignment();
   }
@@ -522,8 +582,10 @@ export function buildAST(tokens) {
   const ast = parseExpression();
 
   if (current < tokens.length) {
+    const t = peek();
+    const pos = t && t.pos !== undefined ? ` at position ${t.pos}` : '';
     throw new Error(
-      `Unexpected token at end: ${JSON.stringify(peek())}`
+      `Unexpected token "${t ? JSON.stringify(t.value || t.name || t.type) : '?'}"${pos}`
     );
   }