@oddo/lang 0.0.2 → 0.0.3

package/dist/index.js

@@ -2633,8 +2633,10 @@ function convertPostfix(cst) {
   return operand;
 }
 function convertFunctionCall(cst) {
+  var _a;
   let callee = convertExpression(getFirstChild(cst, "memberAccess"));
   const leftParens = cst.children.LeftParen || [];
+  const rightParens = cst.children.RightParen || [];
   const questionDots = cst.children.QuestionDot || [];
   const templateLiterals = cst.children.TemplateLiteral || [];
   if (templateLiterals.length > 0 && leftParens.length === 0) {
@@ -2652,11 +2654,16 @@ function convertFunctionCall(cst) {
   const argLists = getAllChildren(cst, "argumentList");
   const allExprs = getAllChildren(cst, "expression");
   const ops = [
-    ...leftParens.map((t2, i) => ({ k: "c", off: t2.startOffset, i, token: t2 })),
+    ...leftParens.map((t2, i) => ({
+      k: "c",
+      off: t2.startOffset,
+      token: t2,
+      rightParen: rightParens[i]
+    })),
     ...dots.map((t2, i) => ({ k: "d", off: t2.startOffset, i })),
     ...brackets.map((t2, i) => {
-      var _a;
-      return { k: "b", off: t2.startOffset, i, end: (_a = rightBrackets[i]) == null ? void 0 : _a.endOffset };
+      var _a2;
+      return { k: "b", off: t2.startOffset, i, end: (_a2 = rightBrackets[i]) == null ? void 0 : _a2.endOffset };
     }),
     ...questionDots.filter((q) => !leftParens.some((p) => Math.abs(p.startOffset - q.endOffset) <= 1)).map((t2, i) => ({ k: "q", off: t2.startOffset, i }))
   ].sort((a, b) => a.off - b.off);
@@ -2664,7 +2671,12 @@ function convertFunctionCall(cst) {
   for (const op of ops) {
     if (op.k === "c") {
       const isOptional = questionDots.some((q) => q.endOffset < op.token.startOffset && op.token.startOffset - q.endOffset <= 1);
-      const argsCST = argLists[op.i];
+      const leftOff = op.token.startOffset;
+      const rightOff = (_a = op.rightParen) == null ? void 0 : _a.endOffset;
+      const argsCST = argLists.find((al) => {
+        const alStart = getFirstTokenOffset(al);
+        return alStart !== void 0 && alStart > leftOff && (rightOff === void 0 || alStart < rightOff);
+      });
       const args = [];
       if (argsCST) {
         const exprs = getAllChildren(argsCST, "expression");
@@ -2684,9 +2696,9 @@ function convertFunctionCall(cst) {
       if (nextBracket) {
         const bIdx = brackets.indexOf(nextBracket);
         const expr = allExprs.find((e) => {
-          var _a;
+          var _a2;
           const o = getFirstTokenOffset(e);
-          return o > nextBracket.startOffset && o < ((_a = rightBrackets[bIdx]) == null ? void 0 : _a.endOffset);
+          return o > nextBracket.startOffset && o < ((_a2 = rightBrackets[bIdx]) == null ? void 0 : _a2.endOffset);
         });
         if (expr) callee = { type: "memberAccess", object: callee, property: convertExpression(expr), computed: true, optional: true };
         ops.splice(ops.findIndex((o) => o.k === "b" && o.i === bIdx), 1);
@@ -2709,6 +2721,7 @@ function convertMemberAccess(cst) {
   const dots = cst.children.Dot || [];
   const questionDots = cst.children.QuestionDot || [];
   const brackets = cst.children.LeftBracket || [];
+  const rightBrackets = cst.children.RightBracket || [];
   const dotDotDots = cst.children.DotDotDot || [];
   if (dots.length === 0 && questionDots.length === 0 && brackets.length === 0) {
     return object;
@@ -2718,85 +2731,96 @@ function convertMemberAccess(cst) {
     allOps.push({ type: "dot", token: dot, optional: false });
   }
   for (const qDot of questionDots) {
-    allOps.push({ type: "dot", token: qDot, optional: true });
-  }
-  allOps.sort((a, b) => a.token.startOffset - b.token.startOffset);
-  const identifiers = cst.children.Identifier || [];
-  let identifierIndex = 0;
-  for (let i = 0; i < allOps.length; i++) {
-    const op = allOps[i];
-    const identifier2 = identifiers[identifierIndex];
-    if (identifier2) {
-      identifierIndex++;
-      object = {
-        type: "memberAccess",
-        object,
-        property: identifier2.image,
-        computed: false,
-        optional: op.optional
-      };
+    const isFollowedByBracket = brackets.some((b) => b.startOffset > qDot.endOffset && b.startOffset - qDot.endOffset <= 1);
+    if (!isFollowedByBracket) {
+      allOps.push({ type: "dot", token: qDot, optional: true });
     }
   }
-  const expressions = getAllChildren(cst, "expression");
-  let expressionIndex = 0;
   for (let i = 0; i < brackets.length; i++) {
     const bracket = brackets[i];
-    const bracketStart = bracket.startOffset;
-    const isOptional = questionDots.some((qDot) => {
-      return qDot.endOffset < bracketStart && bracketStart - qDot.endOffset <= 1;
-    });
-    const rightBrackets = cst.children.RightBracket || [];
     const rightBracket = rightBrackets[i];
     if (!rightBracket) continue;
+    const isOptional = questionDots.some(
+      (qDot) => qDot.endOffset < bracket.startOffset && bracket.startOffset - qDot.endOffset <= 1
+    );
     const dotDotDotsInRange = dotDotDots.filter(
-      (ddd) => ddd.startOffset > bracketStart && ddd.startOffset < rightBracket.startOffset
+      (ddd) => ddd.startOffset > bracket.startOffset && ddd.startOffset < rightBracket.startOffset
     );
-    if (dotDotDotsInRange.length > 0) {
-      if (expressions.length === expressionIndex) {
-        object = {
-          type: "arraySlice",
-          object,
-          start: null,
-          end: null
-        };
-        continue;
-      }
-      if (expressions.length >= expressionIndex + 2) {
-        const startExpr = expressions[expressionIndex];
-        const endExpr = expressions[expressionIndex + 1];
-        expressionIndex += 2;
+    allOps.push({
+      type: "bracket",
+      token: bracket,
+      rightBracket,
+      optional: isOptional,
+      isSlice: dotDotDotsInRange.length > 0
+    });
+  }
+  allOps.sort((a, b) => a.token.startOffset - b.token.startOffset);
+  const identifiers = cst.children.Identifier || [];
+  const expressions = getAllChildren(cst, "expression");
+  let identifierIndex = 0;
+  let expressionIndex = 0;
+  for (const op of allOps) {
+    if (op.type === "dot") {
+      const identifier2 = identifiers[identifierIndex];
+      if (identifier2) {
+        identifierIndex++;
         object = {
-          type: "arraySlice",
+          type: "memberAccess",
           object,
-          start: convertExpression(startExpr),
-          end: convertExpression(endExpr)
+          property: identifier2.image,
+          computed: false,
+          optional: op.optional
         };
-        continue;
       }
-      if (expressions.length === expressionIndex + 1) {
-        const startExpr = expressions[expressionIndex];
-        expressionIndex++;
-        object = {
-          type: "arraySlice",
-          object,
-          start: convertExpression(startExpr),
-          end: null
-        };
-        continue;
+    } else if (op.type === "bracket") {
+      if (op.isSlice) {
+        const exprsInBracket = expressions.filter((e, idx) => {
+          if (idx < expressionIndex) return false;
+          const exprStart = getFirstTokenOffset(e);
+          return exprStart > op.token.startOffset && exprStart < op.rightBracket.startOffset;
+        });
+        if (exprsInBracket.length === 0) {
+          object = {
+            type: "arraySlice",
+            object,
+            start: null,
+            end: null
+          };
+        } else if (exprsInBracket.length >= 2) {
+          const startExpr = expressions[expressionIndex];
+          const endExpr = expressions[expressionIndex + 1];
+          expressionIndex += 2;
+          object = {
+            type: "arraySlice",
+            object,
+            start: convertExpression(startExpr),
+            end: convertExpression(endExpr)
+          };
+        } else {
+          const startExpr = expressions[expressionIndex];
+          expressionIndex++;
+          object = {
+            type: "arraySlice",
+            object,
+            start: convertExpression(startExpr),
+            end: null
+          };
+        }
+      } else {
+        if (expressions.length > expressionIndex) {
+          const exprCst = expressions[expressionIndex];
+          expressionIndex++;
+          const property = convertExpression(exprCst);
+          object = {
+            type: "memberAccess",
+            object,
+            property,
+            computed: true,
+            optional: op.optional
+          };
+        }
       }
     }
-    if (expressions.length > expressionIndex) {
-      const exprCst = expressions[expressionIndex];
-      expressionIndex++;
-      const property = convertExpression(exprCst);
-      object = {
-        type: "memberAccess",
-        object,
-        property,
-        computed: true,
-        optional: isOptional
-      };
-    }
   }
   return object;
 }