@cloudpss/expression 0.6.0-alpha.9 → 0.6.0

package/src/migrator/access.ts

@@ -1,3 +1,5 @@
+import { isVmPrimitive, type VmValue } from '@mirascript/mirascript';
+import { operations, serialize, serializeRecordKey } from '@mirascript/mirascript/subtle';
 import {
     type ConstantNode,
     isConstantNode,
@@ -13,18 +15,17 @@ import {
 import type { Result } from './interface.js';
 import { migrateAtomic, migrateExpr } from './node.js';
 import type { State } from './state.js';
-import { unsupportedNode } from './utils.js';
-import { serialize, serializePropName } from '@mirascript/mirascript/subtle';
+import { constantValue, len, unsupportedNode } from './utils.js';
 
 /** 常量访问 */
-function constIndexing(node: ConstantNode): Result {
+function constIndexing(node: ConstantNode) {
     const { value } = node as ConstantNode<string | number>;
     if (typeof value == 'string') {
-        return { type: 'string', literal: value, code: serialize(value) };
+        return { type: 'string', literal: value, code: serialize(value) } satisfies Result;
     } else if (typeof value == 'number' && Number.isInteger(value) && value > 0) {
-        return { type: 'number', literal: value - 1, code: serialize(value - 1) };
+        return { type: 'number', literal: value - 1, code: serialize(value - 1) } satisfies Result;
     } else {
-        return { code: serialize(value) };
+        return { code: serialize(value) } satisfies Result;
     }
 }
 
@@ -56,13 +57,36 @@ function accessChain(
     const obj = migrateExpr(state, object);
     const chain = index.map((i) => {
         if (typeof i == 'number') return `[${i}]`;
-        const s = serializePropName(i);
+        const s = serializeRecordKey(i);
         if (s !== i) return `[${s}]`;
         return `.${s}`;
     });
+    let type;
+    if (!assignment && obj.global != null) {
+        try {
+            let v: VmValue = obj.global;
+            for (const i of index) {
+                if (v == null) break;
+                v = operations.$Get(v, i);
+            }
+            if (v != null && isVmPrimitive(v)) {
+                type = operations.$Type(v);
+            }
+        } catch (ex) {
+            type = undefined;
+            state.warn(`无法获取变量的类型: ${(ex as Error).message}`);
+        }
+    }
     if (!assignment && typeof index.at(-1) == 'number') {
+        if (chain.length === 1) {
+            return {
+                type,
+                code: `${stringToArray(state, obj).code}${chain[0]}`,
+            };
+        }
         const prev = chain.slice(0, -1).join('');
         return {
+            type,
             code: `${
                 stringToArray(state, {
                     code: `${obj.code}${prev}`,
@@ -71,7 +95,8 @@ function accessChain(
         };
     }
     return {
-        code: `${migrateExpr(state, object).code}${chain.join('')}`,
+        type,
+        code: `${obj.code}${chain.join('')}`,
     };
 }
 
@@ -85,21 +110,45 @@ function access(
         return [node, []];
     }
     const { object, index } = node;
-    if (!index || index.dimensions.length !== 1 || !index.dimensions[0]) {
+    if (!index?.dimensions[0]) {
         return unsupportedNode(state, node);
     }
+    if (index.dimensions.length > 1) {
+        state.warn('多维索引已拆分为多次单维索引');
+        const indices = index.dimensions.map((dim) => {
+            if (isConstantNode(dim)) {
+                const idx = constIndexing(dim);
+                if (idx.type === 'number') {
+                    return idx;
+                }
+            }
+            return { code: `${migrateAtomic(state, dim).code} - 1` };
+        });
+        const obj = migrateExpr(state, object);
+        return {
+            code: `${obj.code}${indices.map((idx) => `[${idx.code}]`).join('')}`,
+        };
+    }
     const dim0 = index.dimensions[0];
 
     if (isRangeNode(dim0)) {
         const obj = migrateExpr(state, object);
-        if (obj.type === 'array' && !dim0.step && isConstantNode(dim0.start) && isConstantNode(dim0.end)) {
+        if (obj.type === 'array' && isConstantNode(dim0.start) && isConstantNode(dim0.end)) {
             const start = constIndexing(dim0.start);
             const end = constIndexing(dim0.end);
+            const step = dim0.step == null ? 1 : constantValue(dim0.step);
             if (start.type === 'number' && end.type === 'number') {
-                return {
-                    type: 'array',
-                    code: `${obj.code}[${start.code}..${end.code}]`,
-                };
+                if (step === 1) {
+                    return {
+                        type: 'array',
+                        code: `${obj.code}[${start.code}..${end.code}]`,
+                    };
+                } else if (step === -1) {
+                    return {
+                        type: 'array',
+                        code: `${obj.code}[${end.code}..${start.code}]::reverse()`,
+                    };
+                }
             }
         }
         const d = unsupportedNode(state, dim0);
@@ -113,22 +162,7 @@ function access(
         if (typeof value != 'string') return unsupportedNode(state, node);
         if (!assignment && value === 'length') {
             const obj = migrateExpr(state, object);
-            if (obj.type === 'string')
-                return {
-                    type: 'number',
-                    code: `len(chars(${obj.code}))`,
-                };
-            if (obj.type === 'array')
-                return {
-                    type: 'number',
-                    code: `len(${obj.code})`,
-                };
-            state.helper(
-                `fn @@length(x) { if type(x) == 'string' { len(chars(x)) } else if type(x) == 'array' { len(x) } } else { x.length } }`,
-            );
-            return {
-                code: `@@length(${obj.code})`,
-            };
+            return len(state, obj);
         }
         const obj = access(state, object, assignment);
         if (Array.isArray(obj)) {
@@ -143,7 +177,7 @@ function access(
         if (index.type === 'string') {
             const obj = access(state, object, assignment);
             if (Array.isArray(obj)) {
-                return [obj[0], [...obj[1], index.literal as string]];
+                return [obj[0], [...obj[1], index.literal]];
             }
             return { code: `${obj.code}[${index.code}]` };
         } else if (index.type === 'number') {
@@ -157,15 +191,11 @@ function access(
                 object.fn.name === 'size' &&
                 object.args.length === 1
             ) {
-                const el = stringToArray(state, migrateAtomic(state, object.args[0]!));
-                return {
-                    type: 'number',
-                    code: `len(${el.code})`,
-                };
+                return len(state, migrateAtomic(state, object.args[0]!));
             }
             const obj = access(state, object, assignment);
             if (Array.isArray(obj)) {
-                return [obj[0], [...obj[1], index.literal as number]];
+                return [obj[0], [...obj[1], index.literal]];
             }
             return { code: `${stringToArray(state, obj).code}[${index.code}]` };
         } else {