circuitscript 0.1.4 → 0.1.7

package/dist/esm/validate/SymbolValidatorVisitor.js

@@ -0,0 +1,163 @@
+import { buildInMethodNamesList } from "../builtinMethods.js";
+import { ParseSymbolType } from "../objects/types.js";
+import { SymbolTable } from "./SymbolTable.js";
+import { BaseVisitor } from "../BaseVisitor.js";
+import { SymbolValidatorContext } from "../globals.js";
+export class SymbolValidatorVisitor extends BaseVisitor {
+    symbolTable = new SymbolTable();
+    filePathStack = [];
+    enterFile(filePath) {
+        this.filePathStack.push(filePath);
+    }
+    exitFile() {
+        this.filePathStack.pop();
+    }
+    getCurrentFile() {
+        return this.filePathStack[this.filePathStack.length - 1];
+    }
+    addSymbolVariable(token, name, value, executor = null) {
+        const useExecutor = executor === null ? this.getExecutor() : executor;
+        this.symbolTable.addVariable(token, this.getCurrentFile(), useExecutor, name, value);
+        this.log2('add symbol variable: ' + name);
+    }
+    addSymbolFunction(token, functionName, funcDefinedParameters) {
+        if (!this.symbolTable.exists(this.getExecutor(), functionName)) {
+            this.symbolTable.addFunction(token, this.getCurrentFile(), this.getExecutor(), functionName, funcDefinedParameters);
+            this.log2('add symbol function: ' + functionName);
+        }
+    }
+    handleAtomSymbol(atom) {
+        const atomId = atom.getText();
+        const executor = this.getExecutor();
+        let tmpSymbol;
+        if (this.symbolTable.exists(executor, atomId)) {
+            tmpSymbol = this.symbolTable.get(executor, atomId);
+        }
+        else {
+            if (buildInMethodNamesList.indexOf(atomId) !== -1) {
+                tmpSymbol = this.symbolTable.addFunction(null, "<builtIn>", this.getRootExecutor(), atomId, {});
+            }
+            else {
+                const foundContext = this.symbolTable.searchParentContext(executor, atomId);
+                if (foundContext === null) {
+                    tmpSymbol = this.symbolTable.addUndefined(this.getCurrentFile(), executor, atomId, atom.getSymbol());
+                    this.log2('symbol not found: ' + atomId);
+                }
+                else {
+                    tmpSymbol = this.symbolTable.get(foundContext, atomId);
+                }
+            }
+        }
+        if (tmpSymbol.type !== ParseSymbolType.Undefined) {
+            this.addSymbolInstance(tmpSymbol, atom.getSymbol());
+        }
+        return tmpSymbol;
+    }
+    addSymbolInstance(symbol, token) {
+        symbol = symbol;
+        if (symbol.instances.indexOf(token) == -1) {
+            symbol.instances.push(token);
+        }
+    }
+    setSymbols(symbolTable) {
+        this.symbolTable = symbolTable;
+    }
+    visitImport_expr = (ctx) => {
+        const ID = ctx.ID().toString();
+        const { pathExists } = this.handleImportFile(ID, false, ctx);
+        if (!pathExists) {
+            this.symbolTable.addUndefined(this.getCurrentFile(), this.getExecutor(), ID, ctx.ID().getSymbol());
+        }
+    };
+    visitAssignment_expr = (ctx) => {
+        const ctxDataExpr = ctx.data_expr();
+        this.visit(ctxDataExpr);
+        const value = this.getResult(ctxDataExpr);
+        const atomId = ctx.atom_expr().ID(0);
+        const atomText = atomId.getText();
+        const executor = this.getExecutor();
+        if (!this.symbolTable.exists(executor, atomText)) {
+            this.addSymbolVariable(atomId.getSymbol(), atomId.getText(), value);
+        }
+        else {
+            const tmpSymbol = this.symbolTable.get(executor, atomText);
+            this.addSymbolInstance(tmpSymbol, atomId.getSymbol());
+        }
+        return null;
+    };
+    visitAtom_expr = (ctx) => {
+        const tmpSymbol = this.handleAtomSymbol(ctx.ID(0));
+        this.setResult(ctx, tmpSymbol);
+    };
+    visitFunction_call_expr = (ctx) => {
+        this.handleAtomSymbol(ctx.ID());
+        if (ctx.trailer_expr().length > 0) {
+            ctx.trailer_expr().forEach(item => {
+                if (item.OPEN_PAREN() && item.CLOSE_PAREN()) {
+                    const params = item.parameters();
+                    if (params) {
+                        this.visit(params);
+                    }
+                }
+            });
+        }
+    };
+    visitValueAtomExpr = (ctx) => {
+        let value = null;
+        const ctxValueExpr = ctx.value_expr();
+        const cxtAtomExpr = ctx.atom_expr();
+        if (ctxValueExpr) {
+            this.visit(ctxValueExpr);
+            value = this.getResult(ctxValueExpr);
+        }
+        else if (cxtAtomExpr) {
+            this.visit(cxtAtomExpr);
+            value = this.getResult(cxtAtomExpr);
+        }
+        this.setResult(ctx, value);
+    };
+    visitUnaryOperatorExpr = (ctx) => {
+        this.visit(ctx.data_expr());
+    };
+    visitMultiplyExpr = (ctx) => {
+        this.visit(ctx.data_expr(0));
+        this.visit(ctx.data_expr(1));
+    };
+    visitAdditionExpr = (ctx) => {
+        this.visit(ctx.data_expr(0));
+        this.visit(ctx.data_expr(1));
+    };
+    visitBinaryOperatorExpr = (ctx) => {
+        this.visit(ctx.data_expr(0));
+        this.visit(ctx.data_expr(1));
+    };
+    visitDataExpr = (ctx) => {
+        return;
+    };
+    visitFunction_def_expr = (ctx) => {
+        const functionName = ctx.ID().getText();
+        let funcDefinedParameters = [];
+        const ctxFunctionArgsExpr = ctx.function_args_expr();
+        if (ctxFunctionArgsExpr) {
+            this.visit(ctxFunctionArgsExpr);
+            funcDefinedParameters = this.getResult(ctxFunctionArgsExpr);
+        }
+        this.addSymbolFunction(ctx.ID().getSymbol(), functionName, funcDefinedParameters);
+        const executionContextName = functionName + SymbolValidatorContext;
+        const passedInParamsNull = funcDefinedParameters.map((param, index) => {
+            return ['position', index, null];
+        });
+        const newExecutor = this.enterNewChildContext(this.executionStack, this.getExecutor(), executionContextName, { netNamespace: "" }, funcDefinedParameters, passedInParamsNull);
+        funcDefinedParameters.forEach(param => {
+            this.addSymbolVariable(param[1], param[0], null, newExecutor);
+        });
+        this.runExpressions(newExecutor, ctx.function_expr());
+        this.executionStack.pop();
+    };
+    getSymbols() {
+        return this.symbolTable;
+    }
+    dumpSymbols() {
+        this.symbolTable.dumpSymbols();
+    }
+}

package/dist/esm/validate.js

@@ -0,0 +1,86 @@
+#! /usr/bin/env node
+import { program } from 'commander';
+import { readFileSync, existsSync } from 'fs';
+import { getSemanticTokens, validateScript } from './helpers.js';
+import { NodeScriptEnvironment } from "./environment.js";
+import { ParseSymbolType } from './objects/types.js';
+export default async function validate() {
+    const env = new NodeScriptEnvironment();
+    NodeScriptEnvironment.setInstance(env);
+    const version = env.getPackageVersion();
+    program
+        .description('generate validation output circuitscript files')
+        .version(version)
+        .argument('[input path]', 'Input path')
+        .argument('[output path]', 'Output path')
+        .option('-i, --input text <input text>', 'Input text directly')
+        .option('-c, --current-directory <path>', 'Set current directory')
+        .option('-w, --watch', 'Watch for file changes')
+        .option('-n, --dump-nets', 'Dump out net information')
+        .option('-d, --dump-data', 'Dump data during parsing')
+        .option('-s, --stats', 'Show stats during generation')
+        .option('-x, --skip-output', 'Skip output generation');
+    if (process.argv.length < 3) {
+        program.help();
+    }
+    program.parse();
+    const options = program.opts();
+    const args = program.args;
+    const watchFileChanges = options.watch;
+    const dumpNets = options.dumpNets;
+    const dumpData = options.dumpData;
+    if (options.currentDirectory) {
+        env.setModuleDirectory(options.currentDirectory);
+    }
+    if (watchFileChanges) {
+        console.log('watching for file changes...');
+    }
+    await env.prepareSVGEnvironment();
+    let inputFilePath = "";
+    if (args.length > 2) {
+        console.log("Error: Extra arguments passed");
+        return;
+    }
+    let scriptData;
+    if (args.length > 0 && args[0]) {
+        inputFilePath = args[0];
+        if (existsSync(inputFilePath)) {
+            scriptData = readFileSync(inputFilePath, { encoding: 'utf-8' });
+        }
+        else {
+            console.error("Error: File could not be found");
+            return;
+        }
+    }
+    else if (options.input) {
+        scriptData = options.input;
+    }
+    else {
+        console.error("Error: No input provided");
+        return;
+    }
+    const scriptOptions = {
+        dumpNets,
+        dumpData,
+        showStats: options.stats,
+        environment: env,
+    };
+    const visitor = await validateScript(inputFilePath, scriptData, scriptOptions);
+    const symbols = visitor.getSymbols().getSymbols();
+    symbols.forEach((value, key) => {
+        if (value.type !== ParseSymbolType.Undefined) {
+            value = value;
+            const token = value.token;
+            console.log(key, value.fileName, token !== null ? (token.line + ":" + token.column) : "");
+            value.instances.forEach(instance => {
+                console.log("    " + instance.line + ":" + instance.column + " " + instance.start);
+            });
+        }
+    });
+    const { parsedTokens } = await getSemanticTokens(scriptData, scriptOptions);
+    parsedTokens.forEach(item => {
+        const { line, column, tokenType, tokenModifiers, textValue } = item;
+        console.log(`${line}:${column} - ${textValue} - ${tokenType} | ${tokenModifiers.join(',')}`);
+    });
+}
+validate();

package/dist/esm/{visitor.mjs → visitor.js}

@@ -1,14 +1,14 @@
-import { ClassComponent } from './objects/ClassComponent.mjs';
-import { NumberOperator, numeric, NumericValue, ParamDefinition } from './objects/ParamDefinition.mjs';
-import { PinDefinition, PinIdType } from './objects/PinDefinition.mjs';
-import { PinTypes } from './objects/PinTypes.mjs';
-import { DeclaredReference, UndeclaredReference } from './objects/types.mjs';
-import { BlockTypes, ComponentTypes, FrameType, GlobalDocumentName, ModuleContainsKeyword, NoNetText, ParamKeys, ReferenceTypes, SymbolPinSide, WireAutoDirection } from './globals.mjs';
-import { PlaceHolderCommands, SymbolDrawingCommands } from './draw_symbols.mjs';
-import { BaseVisitor } from './BaseVisitor.mjs';
-import { getPortType } from './utils.mjs';
-import { UnitDimension } from './helpers.mjs';
-import { FrameParamKeys } from './objects/Frame.mjs';
+import { ClassComponent } from './objects/ClassComponent.js';
+import { NumberOperator, numeric, NumericValue, ParamDefinition } from './objects/ParamDefinition.js';
+import { PinDefinition, PinIdType } from './objects/PinDefinition.js';
+import { PinTypes } from './objects/PinTypes.js';
+import { DeclaredReference, UndeclaredReference } from './objects/types.js';
+import { BlockTypes, ComponentTypes, Delimiter1, FrameType, GlobalDocumentName, ModuleContainsKeyword, NoNetText, ParamKeys, ReferenceTypes, SymbolPinSide, ValidPinSides, WireAutoDirection } from './globals.js';
+import { PlaceHolderCommands, SymbolDrawingCommands } from './draw_symbols.js';
+import { BaseVisitor } from './BaseVisitor.js';
+import { getPortType, RuntimeExecutionError } from './utils.js';
+import { UnitDimension } from './helpers.js';
+import { FrameParamKeys } from './objects/Frame.js';
 export class ParserVisitor extends BaseVisitor {
     visitKeyword_assignment_expr = (ctx) => {
         const id = ctx.ID().getText();
@@ -41,9 +41,14 @@ export class ParserVisitor extends BaseVisitor {
     visitTo_component_expr = (ctx) => {
         ctx.component_select_expr().forEach(item => {
             const [component, pin] = this.visitResult(item);
-            this.getExecutor().toComponent(component, pin, {
-                addSequence: true
-            });
+            try {
+                this.getExecutor().toComponent(component, pin, {
+                    addSequence: true
+                });
+            }
+            catch (err) {
+                throw new RuntimeExecutionError(err.message, ctx.start, ctx.stop);
+            }
         });
         return this.getExecutor().getCurrentPoint();
     };
@@ -58,7 +63,10 @@ export class ParserVisitor extends BaseVisitor {
             componentPin = this.visitResult(ctxDataExprWithAssigment);
         }
         else {
-            const component = this.getExecutor().scope.currentComponent;
+            let component = this.getScope().currentComponent;
+            if (component._pointLinkComponent) {
+                component = component._pointLinkComponent;
+            }
             let pinId = null;
             const ctxPinSelectExpr = ctx.pin_select_expr();
             if (ctxPinSelectExpr) {
@@ -106,6 +114,92 @@ export class ParserVisitor extends BaseVisitor {
         return this.getExecutor().getCurrentPoint();
     };
     visitCreate_component_expr = (ctx) => {
+        const scope = this.getScope();
+        scope.setOnPropertyHandler((path, value, ctx) => {
+            if (path.length === 1) {
+                const [, keyName] = path[0];
+                switch (keyName) {
+                    case 'type':
+                        this.validateString(value, ctx);
+                        break;
+                    case 'angle':
+                    case 'width':
+                    case 'height':
+                        this.validateNumeric(value, ctx);
+                        break;
+                    case 'pins':
+                        if (!(value instanceof Map)) {
+                            this.validateNumeric(value, ctx);
+                        }
+                        break;
+                    case 'copy':
+                        if (value instanceof NumericValue) {
+                            this.validateNumeric(value, ctx);
+                        }
+                        else if (typeof value === 'boolean') {
+                            this.validateBoolean(value, ctx);
+                        }
+                        else {
+                            throw new RuntimeExecutionError("Invalid value for 'copy' property", ctx.start, ctx.end);
+                        }
+                        break;
+                }
+            }
+            else {
+                const [, keyName] = path[0];
+                if (keyName === 'arrange') {
+                    const [sideKeyCtx, sideKeyName] = path[1];
+                    if (ValidPinSides.indexOf(sideKeyName) === -1) {
+                        throw new RuntimeExecutionError(`Invalid side ${sideKeyName} in arrange`, sideKeyCtx.start, sideKeyCtx.stop);
+                    }
+                    else {
+                        if (path.length > 2 && path[2][0] === 'index') {
+                            if (Array.isArray(value)) {
+                                const goodBlank = value.length === 1 &&
+                                    value[0] instanceof NumericValue;
+                                if (!goodBlank) {
+                                    throw new RuntimeExecutionError(`Invalid blank specifier`, ctx.start, ctx.stop);
+                                }
+                            }
+                            else {
+                                if (!(value instanceof NumericValue)) {
+                                    throw new RuntimeExecutionError(`Invalid numeric value for arrange.${sideKeyName}`, ctx.start, ctx.stop);
+                                }
+                            }
+                        }
+                    }
+                }
+                else if (keyName === 'params') {
+                    const [, subKeyName] = path[1];
+                    switch (subKeyName) {
+                        case 'mpn':
+                        case 'refdes':
+                        case 'footprint':
+                            this.validateString(value, ctx);
+                            break;
+                        case 'place':
+                            this.validateBoolean(value, ctx);
+                            break;
+                    }
+                }
+                else if (keyName === 'pins') {
+                    if (path.length === 2) {
+                        if (value.length === 2) {
+                            const [pinType,] = value;
+                            if (pinType instanceof UndeclaredReference) {
+                                throw new RuntimeExecutionError(`Invalid pin type: ${pinType.reference.name}`, ctx.start, ctx.end);
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        scope.enterContext(ctx);
+        ctx.property_expr().forEach(item => {
+            this.visitResult(item);
+        });
+        scope.exitContext();
+        scope.popOnPropertyHandler();
         const properties = this.getPropertyExprList(ctx.property_expr());
         const pins = this.parseCreateComponentPins(properties.get('pins'));
         let instanceName = this.getExecutor().getUniqueInstanceName();
@@ -118,7 +212,7 @@ export class ParserVisitor extends BaseVisitor {
             if (paramValue instanceof NumericValue) {
                 appendValue = paramValue.value;
             }
-            instanceName += '_' + appendValue;
+            instanceName += `${Delimiter1}${appendValue}`;
         }
         const arrange = properties.has('arrange') ?
             properties.get('arrange') : null;
@@ -140,8 +234,13 @@ export class ParserVisitor extends BaseVisitor {
             arrange, display, type, width, height, copy,
             angle, followWireOrientation
         };
-        const createdComponent = this.getExecutor().createComponent(instanceName, pins, params, props);
-        this.setResult(ctx, createdComponent);
+        try {
+            const createdComponent = this.getExecutor().createComponent(instanceName, pins, params, props);
+            this.setResult(ctx, createdComponent);
+        }
+        catch (error) {
+            this.throwWithContext(ctx, error.message);
+        }
     };
     visitCreate_graphic_expr = (ctx) => {
         const ctxId = ctx.ID();
@@ -149,7 +248,7 @@ export class ParserVisitor extends BaseVisitor {
         if (ctxId !== null) {
             const varName = ctxId.getText();
             paramIds.push(varName);
-            this.getExecutor().scope.variables.set(varName, {});
+            this.getScope().variables.set(varName, {});
         }
         const executor = this.getExecutor();
         const stack = [...this.executionStack];
@@ -251,7 +350,7 @@ export class ParserVisitor extends BaseVisitor {
                     useValueArray = [useValueArray];
                 }
                 useValueArray.forEach((value, index) => {
-                    this.getExecutor().scope.variables.set(forVariableNames[index], value);
+                    this.getScope().variables.set(forVariableNames[index], value);
                 });
                 const commands = this.visitResult(ctx.graphic_expressions_block());
                 allCommands = allCommands.concat(commands);
@@ -310,8 +409,16 @@ export class ParserVisitor extends BaseVisitor {
         this.setResult(ctx, [keyName, expressionsBlock]);
     };
     visitProperty_expr = (ctx) => {
-        const keyName = this.visitResult(ctx.property_key_expr());
-        const value = this.visitResult(ctx.property_value_expr());
+        const ctxKey = ctx.property_key_expr();
+        const ctxValue = ctx.property_value_expr();
+        const scope = this.getScope();
+        this.getScope().enterContext(ctxKey);
+        this.getScope().enterContext(ctxValue);
+        const keyName = this.visitResult(ctxKey);
+        const value = this.visitResult(ctxValue);
+        scope.triggerPropertyHandler(value, ctxValue);
+        this.getScope().exitContext();
+        this.getScope().exitContext();
         if (value instanceof UndeclaredReference && (value.reference.parentValue === undefined
             && value.reference.value === undefined)) {
             throw value.throwMessage();
@@ -321,15 +428,21 @@ export class ParserVisitor extends BaseVisitor {
         this.setResult(ctx, map);
     };
     visitSingle_line_property = (ctx) => {
+        this.getScope().enterContext(ctx);
         let value;
         if (ctx.data_expr().length === 1) {
             value = this.visitResult(ctx.data_expr(0));
         }
         else {
-            value = ctx.data_expr().map(item => {
-                return this.visitResult(item);
+            value = ctx.data_expr().map((item, index) => {
+                this.getScope().enterContext(index);
+                const result = this.visitResult(item);
+                this.getScope().triggerPropertyHandler(result, item);
+                this.getScope().exitContext();
+                return result;
             });
         }
+        this.getScope().exitContext();
         this.setResult(ctx, value);
     };
     visitNested_properties_inner = (ctx) => {
@@ -446,15 +559,15 @@ export class ParserVisitor extends BaseVisitor {
     expandModuleContains(component, netNamespace) {
         this.getExecutor().log('expanding module `contains`');
         const executionStack = this.executionStack;
-        const resolveNet = this.createNetResolver(executionStack);
         const executor = this.getExecutor();
-        const executionContextName = executor.namespace + "_"
+        const executionContextName = executor.namespace + Delimiter1
             + component.instanceName
-            + '_' + component.moduleCounter;
-        const tmpNamespace = this.getNetNamespace(netNamespace, "+/" + component.instanceName + "_" + component.moduleCounter);
+            + Delimiter1 + component.moduleCounter;
+        const tmpNamespace = this.getNetNamespace(netNamespace, "+/" + component.instanceName + Delimiter1 + component.moduleCounter);
         const newExecutor = this.enterNewChildContext(executionStack, executor, executionContextName, { netNamespace: tmpNamespace }, [], []);
         component.moduleCounter += 1;
-        newExecutor.resolveNet = resolveNet;
+        newExecutor.resolveNet = this.createNetResolver(executionStack);
+        newExecutor.resolveComponentPinNet = this.createComponentPinNetResolver(executionStack);
         this.visit(component.moduleContainsExpressions);
         const executionContext = executionStack.pop();
         component.moduleExecutionContext = executionContext;
@@ -659,11 +772,13 @@ export class ParserVisitor extends BaseVisitor {
         const executionStack = this.executionStack;
         const functionCounter = { counter: 0 };
         const resolveNet = this.createNetResolver(this.executionStack);
+        const resolveComponentPinNet = this.createComponentPinNetResolver(this.executionStack);
         const __runFunc = (passedInParameters, options) => {
-            const executionContextName = functionName + '_' + functionCounter['counter'];
+            const executionContextName = `${functionName}-${functionCounter['counter']}`;
             const newExecutor = this.enterNewChildContext(executionStack, this.getExecutor(), executionContextName, options, funcDefinedParameters, passedInParameters);
             functionCounter['counter'] += 1;
             newExecutor.resolveNet = resolveNet;
+            newExecutor.resolveComponentPinNet = resolveComponentPinNet;
             const returnValue = this.runExpressions(newExecutor, ctx.function_expr());
             const lastExecution = executionStack.pop();
             const nextLastExecution = executionStack[executionStack.length - 1];
@@ -750,6 +865,9 @@ export class ParserVisitor extends BaseVisitor {
             }
             else if (ctxDataExpr) {
                 useValue = this.visitResult(ctxDataExpr);
+                if (useValue instanceof NumericValue) {
+                    useValue = useValue.toNumber();
+                }
             }
             if (useValue !== null) {
                 this.setResult(ctx, [direction, new UnitDimension(useValue)]);
@@ -891,7 +1009,7 @@ export class ParserVisitor extends BaseVisitor {
                     useValueArray = [useValueArray];
                 }
                 useValueArray.forEach((value, index) => {
-                    this.getExecutor().scope.variables.set(forVariableNames[index], value);
+                    this.getScope().variables.set(forVariableNames[index], value);
                 });
                 this.visit(ctx.expressions_block());
                 keepLooping = true;
@@ -1035,32 +1153,32 @@ export class ParserVisitor extends BaseVisitor {
         return result;
     }
     printNets() {
-        this.getExecutor().scope.printNets();
+        this.getScope().printNets();
     }
     dumpNets() {
-        return this.getExecutor().scope.dumpNets();
+        return this.getScope().dumpNets();
     }
     dumpUniqueNets() {
-        const nets = this.getExecutor().scope.getNets();
+        const nets = this.getScope().getNets();
         return nets.reduce((accum, [, , net]) => {
             accum.push(net);
             return accum;
         }, []);
     }
     dumpVariables() {
-        return this.getExecutor().scope.variables;
+        return this.getScope().variables;
     }
     dumpInstances() {
-        return this.getExecutor().scope.instances;
+        return this.getScope().instances;
     }
     dump2() {
-        const instances = this.getExecutor().scope.instances;
+        const instances = this.getScope().instances;
         const items = [];
         for (const [instanceName, instance] of instances) {
             if (instance.assignedRefDes === null) {
                 continue;
             }
-            const pinNets = this.resolveNets(this.getExecutor().scope, instance);
+            const pinNets = this.resolveNets(this.getScope(), instance);
             const componentItem = {
                 name: instanceName,
                 refdes: instance.assignedRefDes,
@@ -1075,9 +1193,9 @@ export class ParserVisitor extends BaseVisitor {
     }
     getNetList() {
         const netlist = [];
-        const instances = this.getExecutor().scope.instances;
+        const instances = this.getScope().instances;
         for (const [instanceName, instance] of instances) {
-            const pinNets = this.resolveNets(this.getExecutor().scope, instance);
+            const pinNets = this.resolveNets(this.getScope(), instance);
             const componentItem = {
                 instanceName,
                 instance,
@@ -1108,7 +1226,7 @@ export class ParserVisitor extends BaseVisitor {
     annotateComponents() {
         this.log('===== annotate components =====');
         const annotater = new ComponentAnnotater();
-        const instances = this.getExecutor().scope.instances;
+        const instances = this.getScope().instances;
         const toAnnotate = [];
         for (const [, instance] of instances) {
             if (instance.typeProp === ComponentTypes.net
@@ -1145,7 +1263,7 @@ export class ParserVisitor extends BaseVisitor {
         this.log('');
     }
     applySheetFrameComponent() {
-        const baseScope = this.getExecutor().scope;
+        const baseScope = this.getScope();
         const document = baseScope.variables.get(GlobalDocumentName);
         let frameComponent = null;
         if (document && document[FrameParamKeys.SheetType]) {