@faicad/faijs 0.30.9 → 0.32.2

package/dist/lang/metadata-extractor.js

@@ -485,6 +485,77 @@ function checkDim(node, expectedDim, ctx) {
         return;
     }
 }
+/**
+ * D8+: Recursively check an AST value against a structured {@link DimSpec}.
+ *
+ * Mirrors `fmtValueWithSpec` in codegen.ts but at the AST level: descends into
+ * nested arrays/objects and dispatches `tagged` specs by a discriminator field.
+ * Unlisted fields and unknown discriminator values are skipped (bare passthrough).
+ */
+function checkValueWithSpec(node, spec, ctx) {
+    if (!node)
+        return;
+    switch (spec.kind) {
+        case 'plain':
+            return;
+        case 'dim': {
+            // `'plain'` in a `dim` spec = no dimension check (passthrough).
+            if (spec.dim === 'plain')
+                return;
+            checkDim(node, spec.dim, ctx);
+            // Array (vec/point) → element-wise
+            if (node.type === 'ArrayExpression') {
+                for (const el of node.elements ?? []) {
+                    if (el)
+                        checkDim(el, spec.dim, ctx);
+                }
+            }
+            return;
+        }
+        case 'array': {
+            if (node.type === 'ArrayExpression') {
+                for (const el of node.elements ?? []) {
+                    if (el)
+                        checkValueWithSpec(el, spec.item, ctx);
+                }
+            }
+            return;
+        }
+        case 'object': {
+            if (node.type === 'ObjectExpression') {
+                for (const prop of node.properties) {
+                    if (prop?.type !== 'Property')
+                        continue;
+                    const keyNode = prop.key;
+                    if (keyNode?.type !== 'Identifier')
+                        continue;
+                    const fieldSpec = spec.fields[keyNode.name];
+                    if (fieldSpec)
+                        checkValueWithSpec(prop.value, fieldSpec, ctx);
+                }
+            }
+            return;
+        }
+        case 'tagged': {
+            if (node.type === 'ObjectExpression') {
+                for (const prop of node.properties) {
+                    if (prop?.type !== 'Property')
+                        continue;
+                    const keyNode = prop.key;
+                    if (keyNode?.type !== 'Identifier' || keyNode.name !== spec.key)
+                        continue;
+                    if (prop.value?.type === 'Literal' && typeof prop.value.value === 'string') {
+                        const caseSpec = spec.cases[prop.value.value];
+                        if (caseSpec)
+                            checkValueWithSpec(node, caseSpec, ctx);
+                    }
+                    return;
+                }
+            }
+            return;
+        }
+    }
+}
 /**
  * 在折叠之前记录一条参数槽（ArgSource）。
  *
@@ -1157,6 +1228,8 @@ export function extractMetadata(code, options) {
     const argSources = [];
     // P6/D8: dimension 校验错误累积（跨语句共享）
     const allDimErrors = [];
+    // P6/D8+: dimension 校验警告累积（dimCheck='warn' 的 op；不阻断）
+    const allDimWarnings = [];
     // ── 逐顶层语句分类 ──
     for (const stmtNode of bodyNodes) {
         const rawLine = lineOf(stmtNode);
@@ -1172,6 +1245,7 @@ export function extractMetadata(code, options) {
             argSources,
             opDims: options?.opDims,
             dimErrors: allDimErrors,
+            dimWarnings: allDimWarnings,
         };
         switch (stmtNode.type) {
             case 'ImportDeclaration':
@@ -1326,7 +1400,7 @@ export function extractMetadata(code, options) {
     if (allDimErrors.length > 0) {
         throw allDimErrors[0];
     }
-    return { lines, params, imports, functions, blocks, keep: symbols.keep, meta, terminalShapes, argSources, names };
+    return { lines, params, imports, functions, blocks, keep: symbols.keep, meta, terminalShapes, argSources, names, dimWarnings: allDimWarnings };
 }
 function isLiteralValue(init) {
     return init.type === 'Literal';
@@ -1459,23 +1533,70 @@ function classifyOpCall(call, line, vctx, opts) {
  */
 function checkOpCallDims(call, calleeKey, ctx) {
     const decl = ctx.opDims?.[calleeKey];
-    if (!decl || !decl.paramDims)
+    if (!decl)
         return;
     const args = call.arguments ?? [];
     if (args.length === 0)
         return;
-    const slotMap = decl.slotMap;
-    const shapeArity = slotMap?.shapeArity ?? 0;
-    // ── Object form ──
-    // Look for an ObjectExpression arg that contains keys matching paramDims.
-    // It could be at position `shapeArity` (with slotMap) or at any position
-    // (without slotMap — e.g. fai_extrude(shape, { length: 5 })).
-    if (slotMap) {
-        const firstNonShape = args[shapeArity];
-        if (firstNonShape?.type === 'ObjectExpression') {
-            const hasDimKeys = firstNonShape.properties.some((p) => p?.type === 'Property' && p.key?.type === 'Identifier' && p.key.name in decl.paramDims);
-            if (hasDimKeys) {
-                for (const prop of firstNonShape.properties) {
+    // D8+: redirect dim errors to warnings for ops in 'warn' mode
+    const savedTarget = ctx.dimErrors;
+    if (decl.dimCheck === 'warn') {
+        ctx.dimErrors = ctx.dimWarnings;
+    }
+    try {
+        // D8+: recursive spec check (e.g. cad.sketch's shapes[]/constraints[])
+        if (decl.spec) {
+            for (const arg of args) {
+                if (arg?.type === 'ObjectExpression') {
+                    checkValueWithSpec(arg, decl.spec, ctx);
+                    break;
+                }
+            }
+        }
+        if (!decl.paramDims)
+            return;
+        const slotMap = decl.slotMap;
+        const shapeArity = slotMap?.shapeArity ?? 0;
+        // ── Object form ──
+        // Look for an ObjectExpression arg that contains keys matching paramDims.
+        // It could be at position `shapeArity` (with slotMap) or at any position
+        // (without slotMap — e.g. fai_extrude(shape, { length: 5 })).
+        if (slotMap) {
+            const firstNonShape = args[shapeArity];
+            if (firstNonShape?.type === 'ObjectExpression') {
+                const hasDimKeys = firstNonShape.properties.some((p) => p?.type === 'Property' && p.key?.type === 'Identifier' && p.key.name in decl.paramDims);
+                if (hasDimKeys) {
+                    for (const prop of firstNonShape.properties) {
+                        if (prop?.type !== 'Property')
+                            continue;
+                        const keyNode = prop.key;
+                        if (keyNode?.type !== 'Identifier')
+                            continue;
+                        const paramName = keyNode.name;
+                        const dim = decl.paramDims[paramName];
+                        if (!dim || dim === 'plain')
+                            continue;
+                        checkDim(prop.value, dim, ctx);
+                        if (slotMap.vec3Keys?.includes(paramName) && prop.value?.type === 'ArrayExpression') {
+                            for (const el of prop.value.elements ?? []) {
+                                if (el)
+                                    checkDim(el, dim, ctx);
+                            }
+                        }
+                    }
+                    return;
+                }
+            }
+        }
+        else {
+            // No slotMap — scan all args for ObjectExpression with dim keys
+            for (const arg of args) {
+                if (arg?.type !== 'ObjectExpression')
+                    continue;
+                const hasDimKeys = arg.properties.some((p) => p?.type === 'Property' && p.key?.type === 'Identifier' && p.key.name in decl.paramDims);
+                if (!hasDimKeys)
+                    continue;
+                for (const prop of arg.properties) {
                     if (prop?.type !== 'Property')
                         continue;
                     const keyNode = prop.key;
@@ -1483,67 +1604,41 @@ function checkOpCallDims(call, calleeKey, ctx) {
                         continue;
                     const paramName = keyNode.name;
                     const dim = decl.paramDims[paramName];
-                    if (!dim)
+                    if (!dim || dim === 'plain')
                         continue;
                     checkDim(prop.value, dim, ctx);
-                    if (slotMap.vec3Keys?.includes(paramName) && prop.value?.type === 'ArrayExpression') {
-                        for (const el of prop.value.elements ?? []) {
-                            if (el)
-                                checkDim(el, dim, ctx);
-                        }
-                    }
                 }
                 return;
             }
         }
-    }
-    else {
-        // No slotMap — scan all args for ObjectExpression with dim keys
-        for (const arg of args) {
-            if (arg?.type !== 'ObjectExpression')
-                continue;
-            const hasDimKeys = arg.properties.some((p) => p?.type === 'Property' && p.key?.type === 'Identifier' && p.key.name in decl.paramDims);
-            if (!hasDimKeys)
+        // ── Positional form ──
+        if (!slotMap)
+            return;
+        const keys = slotMap.keys;
+        const vec3Keys = new Set(slotMap.vec3Keys ?? []);
+        let keyIdx = 0;
+        for (let i = shapeArity; i < args.length && keyIdx < keys.length; i++) {
+            const arg = args[i];
+            if (arg?.type === 'ObjectExpression')
+                break; // trailing options object
+            const paramName = keys[keyIdx];
+            const dim = decl.paramDims[paramName];
+            keyIdx++;
+            if (!dim || dim === 'plain')
                 continue;
-            for (const prop of arg.properties) {
-                if (prop?.type !== 'Property')
-                    continue;
-                const keyNode = prop.key;
-                if (keyNode?.type !== 'Identifier')
-                    continue;
-                const paramName = keyNode.name;
-                const dim = decl.paramDims[paramName];
-                if (!dim)
-                    continue;
-                checkDim(prop.value, dim, ctx);
+            if (vec3Keys.has(paramName) && arg?.type === 'ArrayExpression') {
+                for (const el of arg.elements ?? []) {
+                    if (el)
+                        checkDim(el, dim, ctx);
+                }
             }
-            return;
-        }
-    }
-    // ── Positional form ──
-    if (!slotMap)
-        return;
-    const keys = slotMap.keys;
-    const vec3Keys = new Set(slotMap.vec3Keys ?? []);
-    let keyIdx = 0;
-    for (let i = shapeArity; i < args.length && keyIdx < keys.length; i++) {
-        const arg = args[i];
-        if (arg?.type === 'ObjectExpression')
-            break; // trailing options object
-        const paramName = keys[keyIdx];
-        const dim = decl.paramDims[paramName];
-        keyIdx++;
-        if (!dim)
-            continue;
-        if (vec3Keys.has(paramName) && arg?.type === 'ArrayExpression') {
-            for (const el of arg.elements ?? []) {
-                if (el)
-                    checkDim(el, dim, ctx);
+            else if (arg) {
+                checkDim(arg, dim, ctx);
             }
         }
-        else if (arg) {
-            checkDim(arg, dim, ctx);
-        }
+    }
+    finally {
+        ctx.dimErrors = savedTarget;
     }
 }
 /**