circuitscript 0.3.2 → 0.4.1

package/dist/cjs/validate/validateScript.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateScript = void 0;
+const helpers_js_1 = require("../helpers.js");
+const utils_js_1 = require("../utils.js");
+const SymbolValidatorResolveVisitor_js_1 = require("./SymbolValidatorResolveVisitor.js");
+const SymbolValidatorVisitor_js_1 = require("./SymbolValidatorVisitor.js");
+async function validateScript(filePath, scriptData, options) {
+    const { parser } = (0, helpers_js_1.prepareFile)(scriptData);
+    parser.removeErrorListeners();
+    parser.errorHandler = new helpers_js_1.ParseErrorStrategy();
+    parser.addErrorListener(new helpers_js_1.TokenErrorListener());
+    const tree = parser.script();
+    const visitor = new SymbolValidatorVisitor_js_1.SymbolValidatorVisitor(true, null, options.environment);
+    await visitor.resolveImportsAndLoad(filePath, scriptData);
+    visitor.enterFile(filePath);
+    visitor.onImportFile = (visitor, filePath, textData) => {
+        visitor.enterFile(filePath);
+        let hasError = false;
+        let hasParseError = false;
+        if (textData !== null) {
+            const { parser } = (0, helpers_js_1.prepareFile)(textData);
+            const tree = parser.script();
+            try {
+                visitor.visit(tree);
+                visitor.exitFile();
+            }
+            catch (err) {
+                console.log('got an error while parsing tree: ', err);
+                hasParseError = true;
+                hasError = true;
+                throw new utils_js_1.ParseError(`Error parsing validation in imported file: ${err}`);
+            }
+        }
+        else {
+            console.log('file does not exist!');
+            hasError = true;
+        }
+        return {
+            hasError, hasParseError
+        };
+    };
+    visitor.visit(tree);
+    const symbolTable = visitor.getSymbols();
+    symbolTable.clearUndefined();
+    const visitorResolver = new SymbolValidatorResolveVisitor_js_1.SymbolValidatorResolveVisitor(true, null, options.environment);
+    visitorResolver.loadedFiles = visitor.loadedFiles;
+    visitorResolver.enterFile(filePath);
+    visitorResolver.setSymbols(visitor.getSymbols());
+    visitorResolver.onImportFile = visitor.onImportFile;
+    visitorResolver.visit(tree);
+    return visitorResolver;
+}
+exports.validateScript = validateScript;

package/dist/cjs/validate.js

@@ -3,8 +3,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const fs_1 = require("fs");
-const helpers_js_1 = require("./helpers.js");
-const environment_js_1 = require("./environment.js");
+const getSemanticTokens_js_1 = require("./semantic-tokens/getSemanticTokens.js");
+const validateScript_js_1 = require("./validate/validateScript.js");
+const environment_js_1 = require("./environment/environment.js");
 const types_js_1 = require("./objects/types.js");
 async function validate() {
     const env = new environment_js_1.NodeScriptEnvironment();
@@ -67,7 +68,7 @@ async function validate() {
         showStats: options.stats,
         environment: env,
     };
-    const visitor = await (0, helpers_js_1.validateScript)(inputFilePath, scriptData, scriptOptions);
+    const visitor = await (0, validateScript_js_1.validateScript)(inputFilePath, scriptData, scriptOptions);
     const symbols = visitor.getSymbols().getSymbols();
     const undefinedSymbols = [];
     console.log('----- symbols -----');
@@ -85,7 +86,7 @@ async function validate() {
         }
     });
     console.log('----- tokens -----');
-    const { parsedTokens } = await (0, helpers_js_1.getSemanticTokens)(scriptData, scriptOptions);
+    const { parsedTokens } = await (0, getSemanticTokens_js_1.getSemanticTokens)(inputFilePath, scriptData, scriptOptions);
     console.log('----- dump tokens -----');
     parsedTokens.forEach(item => {
         const { line, column, tokenType, tokenModifiers, textValue } = item;

package/dist/cjs/visitor.js

@@ -8,23 +8,18 @@ const PinTypes_js_1 = require("./objects/PinTypes.js");
 const types_js_1 = require("./objects/types.js");
 const globals_js_1 = require("./globals.js");
 const utils_js_1 = require("./utils.js");
-const draw_symbols_js_1 = require("./draw_symbols.js");
+const draw_symbols_js_1 = require("./render/draw_symbols.js");
 const BaseVisitor_js_1 = require("./BaseVisitor.js");
 const utils_js_2 = require("./utils.js");
 const helpers_js_1 = require("./helpers.js");
 const Frame_js_1 = require("./objects/Frame.js");
-const ComponentAnnotater_js_1 = require("./ComponentAnnotater.js");
+const ComponentAnnotater_js_1 = require("./annotate/ComponentAnnotater.js");
 const ComponentMatchConditions_js_1 = require("./ComponentMatchConditions.js");
 class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
     constructor(silent = false, onErrorHandler = null, environment) {
         super(silent, onErrorHandler, environment);
         this.componentCreationIndex = 0;
         this.creationCtx = new Map();
-        this.visitKeyword_assignment_expr = (ctx) => {
-            const id = ctx.ID().getText();
-            const value = this.visitResult(ctx.data_expr());
-            this.setResult(ctx, [id, value]);
-        };
         this.visitPin_select_expr = (ctx) => {
             let pinId = null;
             const ctxData = ctx.data_expr();
@@ -159,22 +154,19 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             if (ctx.path_block() === null) {
                 this.getExecutor().closeOpenPathBlocks();
             }
-            const ctxPathBlock = ctx.path_block();
-            const ctxNotPathBlock = ctx.graph_linear_expression();
-            if (ctxPathBlock) {
-                this.visit(ctxPathBlock);
-            }
-            if (ctxNotPathBlock) {
-                this.visit(ctxNotPathBlock);
-            }
+            this.visitChildren(ctx);
             if (ctx.start && ctx.stop) {
                 const startToken = ctx.start;
                 const stopToken = ctx.stop;
-                const annotationKey = this.getRefdesFileAnnotation(this.getCurrentFile(), startToken.line, startToken.column, stopToken.line, stopToken.column);
-                if (this.refdesFileAnnotations.has(annotationKey)) {
-                    let refdesValue = this.refdesFileAnnotations.get(annotationKey);
-                    refdesValue = refdesValue.split(',')[0];
-                    this.setCurrentComponentRefdes(refdesValue, true);
+                if (this.filePathStack.length > 0) {
+                    const useFilePath = this.getCurrentFile();
+                    const annotationKey = this.getRefdesFileAnnotationKey(useFilePath, startToken.line, startToken.column, stopToken.line, stopToken.column);
+                    if (this.refdesFileAnnotations.has(annotationKey)) {
+                        this.log(`refdes annotation key matched: ${annotationKey}`);
+                        let refdesValue = this.refdesFileAnnotations.get(annotationKey);
+                        refdesValue = refdesValue.split(',')[0];
+                        this.setCurrentComponentRefdes(refdesValue, true);
+                    }
                 }
             }
         };
@@ -182,12 +174,10 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             const scope = this.getScope();
             scope.setOnPropertyHandler(this.createComponentPropertyValidator());
             scope.enterContext(ctx);
-            ctx.property_expr().forEach(item => {
-                this.visitResult(item);
-            });
+            const ctxPropertiesBlock = ctx.properties_block();
+            const properties = this.visitResult(ctxPropertiesBlock);
             scope.exitContext();
             scope.popOnPropertyHandler();
-            const properties = this.getPropertyExprList(ctx.property_expr());
             let instanceName = this.getExecutor().getUniqueInstanceName();
             const propParams = properties.get('params');
             const params = this.parseCreateComponentParams(propParams);
@@ -288,9 +278,9 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                 throw "Invalid command!";
             }
             let parameters = [];
-            const ctxNestedProperties = ctx.nested_properties_inner();
-            if (ctxNestedProperties) {
-                const nestedKeyValues = this.visitResult(ctxNestedProperties);
+            const ctxPropertiesBlock = ctx.properties_block();
+            if (ctxPropertiesBlock) {
+                const nestedKeyValues = this.visitResult(ctxPropertiesBlock);
                 nestedKeyValues.forEach((value, key) => {
                     parameters.push(['keyword', key, (0, utils_js_1.unwrapValue)(value)]);
                 });
@@ -385,10 +375,6 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
         this.visitProperty_expr = (ctx) => {
             const ctxKey = ctx.property_key_expr();
             const ctxValue = ctx.property_value_expr();
-            const extraValue = ctx._extra;
-            if (extraValue) {
-                console.log('extra', extraValue.text);
-            }
             const scope = this.getScope();
             this.getScope().enterContext(ctxKey);
             this.getScope().enterContext(ctxValue);
@@ -423,18 +409,25 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             this.getScope().exitContext();
             this.setResult(ctx, value);
         };
-        this.visitNested_properties_inner = (ctx) => {
+        this.visitProperties_block = (ctx) => {
             const result = new Map();
-            ctx.property_expr().forEach((item) => {
+            const keyCounter = new Map();
+            ctx.property_expr().forEach(item => {
                 const property = this.visitResult(item);
                 for (const [key, value] of property) {
-                    result.set(key, value);
+                    let useKey = key;
+                    const counterValue = keyCounter.get(key) ?? 0;
+                    keyCounter.set(key, counterValue + 1);
+                    if (counterValue > 0) {
+                        useKey = key + ':' + counterValue;
+                    }
+                    result.set(useKey, value);
                 }
             });
             this.setResult(ctx, result);
         };
         this.visitNested_properties = (ctx) => {
-            this.setResult(ctx, this.visitResult(ctx.nested_properties_inner()));
+            this.passResult(ctx, ctx.children[0]);
         };
         this.visitProperty_key_expr = (ctx) => {
             const ctxID = ctx.ID();
@@ -458,22 +451,25 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             const ctxDataExpr = ctx.data_expr();
             const ctxAssignmentExpr = ctx.assignment_expr();
             if (ctxDataExpr) {
-                dataResult = this.visitResult(ctxDataExpr);
                 componentCtx = ctxDataExpr;
+                this.setResult(ctxDataExpr, { keepReference: true });
+                const reference = this.visitResult(ctxDataExpr);
+                if (reference.found) {
+                    dataResult = (0, utils_js_1.unwrapValue)(reference);
+                }
+                else {
+                    const { trailers = [], rootValue = null } = reference;
+                    if (rootValue instanceof ClassComponent_js_1.ClassComponent && trailers.length > 0
+                        && trailers[0] === globals_js_1.ModuleContainsKeyword) {
+                        dataResult = rootValue;
+                        this.placeModuleContains(dataResult);
+                    }
+                }
             }
             else if (ctxAssignmentExpr) {
                 dataResult = this.visitResult(ctxAssignmentExpr);
                 componentCtx = ctxAssignmentExpr;
             }
-            if (dataResult instanceof types_js_1.AnyReference) {
-                const { trailers = [], rootValue = null } = dataResult;
-                if (rootValue instanceof ClassComponent_js_1.ClassComponent
-                    && trailers.length > 0
-                    && trailers[0] === globals_js_1.ModuleContainsKeyword) {
-                    dataResult = rootValue;
-                    this.placeModuleContains(dataResult);
-                }
-            }
             dataResult = (0, utils_js_1.unwrapValue)(dataResult);
             if (dataResult === null || dataResult === undefined) {
                 this.throwWithContext(componentCtx, "Could not find component: " + componentCtx.getText());
@@ -487,18 +483,12 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                 const modifiers = ctx.component_modifier_expr();
                 modifiers.forEach(modifier => {
                     const modifierText = modifier.ID(0).getText();
-                    const ctxValueExpr = modifier.value_expr();
-                    const ctxID2 = modifier.ID(1);
-                    let result = null;
-                    if (ctxValueExpr) {
-                        result = this.visitResult(ctxValueExpr);
-                    }
-                    else if (ctxID2) {
-                        result = ctxID2.getText();
-                    }
+                    const ctxDataExpr = modifier.data_expr();
+                    this.setResult(ctxDataExpr, { keepReference: true });
+                    const result = this.visitResult(ctxDataExpr);
                     let shouldIgnoreWireOrientation = false;
                     if (modifierText === globals_js_1.ParamKeys.flip) {
-                        const flipValue = result;
+                        const flipValue = result.name;
                         if (flipValue.indexOf('x') !== -1) {
                             defaultUnit.setParam(globals_js_1.ParamKeys.flipX, (0, ParamDefinition_js_1.numeric)(1));
                             shouldIgnoreWireOrientation = true;
@@ -513,7 +503,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                         shouldIgnoreWireOrientation = true;
                     }
                     else if (modifierText === 'anchor') {
-                        dataResult.setParam('anchor', result);
+                        dataResult.setParam('anchor', result.name);
                     }
                     if (shouldIgnoreWireOrientation) {
                         defaultUnit.useWireOrientationAngle = false;
@@ -538,31 +528,28 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
         };
         this.visitUnaryOperatorExpr = (ctx) => {
             let value = this.visitResult(ctx.data_expr());
-            const unaryOp = ctx.unary_operator();
-            if (unaryOp) {
-                if (unaryOp.Not()) {
-                    if (typeof value === "boolean") {
-                        value = !value;
-                    }
-                    else if (value instanceof ParamDefinition_js_1.NumericValue) {
-                        value = (value.toNumber() === 0) ? true : false;
-                    }
-                    else {
-                        throw "Failed to do Not operator";
-                    }
+            if (ctx.Not()) {
+                if (typeof value === "boolean") {
+                    value = !value;
                 }
-                else if (unaryOp.Minus()) {
-                    if (value instanceof ParamDefinition_js_1.NumericValue) {
-                        value = value.neg();
-                    }
-                    else {
-                        throw "Failed to do Negation operator";
-                    }
+                else if (value instanceof ParamDefinition_js_1.NumericValue) {
+                    value = (value.toNumber() === 0) ? true : false;
+                }
+                else {
+                    throw "Failed to do Not operator";
+                }
+            }
+            else if (ctx.Minus()) {
+                if (value instanceof ParamDefinition_js_1.NumericValue) {
+                    value = value.neg();
+                }
+                else {
+                    throw "Failed to do Negation operator";
                 }
             }
             this.setResult(ctx, value);
         };
-        this.visitDataExpr = (ctx) => {
+        this.visitCreate_expr = (ctx) => {
             let value;
             const ctxCreateComponentExpr = ctx.create_component_expr();
             const ctxCreateGraphicExpr = ctx.create_graphic_expr();
@@ -581,6 +568,10 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             }
             this.setResult(ctx, value);
         };
+        this.visitCreateExpr = (ctx) => {
+            const result = this.visitResult(ctx.create_expr());
+            this.setResult(ctx, result);
+        };
         this.visitBinaryOperatorExpr = (ctx) => {
             const ctx0 = ctx.data_expr(0);
             const ctx1 = ctx.data_expr(1);
@@ -592,24 +583,23 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             if (value2 instanceof ParamDefinition_js_1.NumericValue) {
                 value2 = value2.toNumber();
             }
-            const binaryOperatorType = ctx.binary_operator();
             let result = null;
-            if (binaryOperatorType.Equals()) {
+            if (ctx.Equals()) {
                 result = value1 == value2;
             }
-            else if (binaryOperatorType.NotEquals()) {
+            else if (ctx.NotEquals()) {
                 result = value1 != value2;
             }
-            else if (binaryOperatorType.GreaterThan()) {
+            else if (ctx.GreaterThan()) {
                 result = value1 > value2;
             }
-            else if (binaryOperatorType.GreatOrEqualThan()) {
+            else if (ctx.GreatOrEqualThan()) {
                 result = value1 >= value2;
             }
-            else if (binaryOperatorType.LessThan()) {
+            else if (ctx.LessThan()) {
                 result = value1 < value2;
             }
-            else if (binaryOperatorType.LessOrEqualThan()) {
+            else if (ctx.LessOrEqualThan()) {
                 result = value1 <= value2;
             }
             this.setResult(ctx, result);
@@ -703,8 +693,8 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             }
             const executionStack = this.executionStack;
             const functionCounter = { counter: 0 };
-            const resolveNet = this.createNetResolver(this.executionStack);
-            const resolveComponentPinNet = this.createComponentPinNetResolver(this.executionStack);
+            const resolveNet = this.createNetResolver(executionStack);
+            const resolveComponentPinNet = this.createComponentPinNetResolver(executionStack);
             const __runFunc = (passedInParameters, options) => {
                 const executor = this.getExecutor();
                 const functionCounterIndex = functionCounter['counter'];
@@ -719,41 +709,23 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             };
             this.getExecutor().createFunction(this.getExecutor().namespace, functionName, __runFunc, ctx, uniqueFunctionID);
         };
-        this.visitPin_select_expr2 = (ctx) => {
-            const ctxStringValue = ctx.STRING_VALUE();
-            const ctxIntegerValue = ctx.INTEGER_VALUE();
-            let pinIdValue;
-            let pinId = null;
-            if (ctxStringValue) {
-                pinIdValue = this.prepareStringValue(ctxStringValue.getText());
-            }
-            else if (ctxIntegerValue) {
-                pinIdValue = Number(ctxIntegerValue.getText());
-            }
-            if (pinIdValue !== undefined) {
-                pinId = new PinDefinition_js_1.PinId(pinIdValue);
-            }
-            else {
-                throw new utils_js_2.RuntimeExecutionError("Invalid select pin", ctx);
-            }
-            this.setResult(ctx, pinId);
-        };
         this.visitAt_block_pin_expr = (ctx) => {
             const executor = this.getExecutor();
             const [currentComponent, currentPin] = executor.getCurrentPoint();
             executor.closeOpenPathBlocks();
-            const atPin = this.visitResult(ctx.pin_select_expr2());
+            const propKey = this.visitResult(ctx.property_key_expr());
+            const atPin = new PinDefinition_js_1.PinId(propKey);
             executor.atComponent(currentComponent, atPin, {
                 addSequence: true
             });
             executor.log('at block pin expressions');
-            const ctxAtBlockSimple = ctx.at_block_pin_expression_simple();
-            const ctxAtBlockComplex = ctx.at_block_pin_expression_complex();
-            if (ctxAtBlockSimple) {
-                this.visit(ctxAtBlockSimple);
+            const ctxExpression = ctx.expression();
+            const ctxExpressionsBlock = ctx.expressions_block();
+            if (ctxExpression) {
+                this.visit(ctxExpression);
             }
-            else if (ctxAtBlockComplex) {
-                this.visit(ctxAtBlockComplex);
+            else if (ctxExpressionsBlock) {
+                this.visit(ctxExpressionsBlock);
             }
             executor.log('end at block pin expressions');
             executor.atComponent(currentComponent, currentPin);
@@ -782,63 +754,33 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             executor.scope.setCurrent(currentComponent, currentPin);
             executor.log('leaving at block');
         };
-        this.visitAt_block_pin_expression_simple = (ctx) => {
-            const ctxExpression = ctx.expression();
-            if (ctxExpression) {
-                this.visit(ctxExpression);
-            }
-            else if (ctx.NOT_CONNECTED()) {
-                return;
-            }
-        };
-        this.visitAt_block_pin_expression_complex = (ctx) => {
-            this.visit(ctx.expressions_block());
-        };
-        this.visitWire_expr_direction_only = (ctx) => {
-            const value = ctx.ID().getText();
-            if (value === globals_js_1.WireAutoDirection.Auto || value === globals_js_1.WireAutoDirection.Auto_) {
-                this.setResult(ctx, [value]);
-            }
-            else {
-                throw 'Invalid direction for wire';
-            }
-        };
-        this.visitWire_expr_direction_value = (ctx) => {
-            const direction = ctx.ID().getText();
-            if (this.acceptedDirections.indexOf(direction) !== -1) {
-                let useValue = null;
-                const ctxIntegerValue = ctx.INTEGER_VALUE();
-                const ctxDataExpr = ctx.data_expr();
-                if (ctxIntegerValue) {
-                    useValue = Number(ctxIntegerValue);
+        this.visitWire_expr = (ctx) => {
+            const segments = [];
+            ctx.ID().forEach((ctxId, index) => {
+                const value = ctxId.getText();
+                const ctxDataExpr = ctx.data_expr(index);
+                if ((value === globals_js_1.WireAutoDirection.Auto || value === globals_js_1.WireAutoDirection.Auto_) && ctxDataExpr === null) {
+                    segments.push([value]);
                 }
-                else if (ctxDataExpr) {
+                else if (this.acceptedDirections.indexOf(value) !== -1 && ctxDataExpr) {
+                    let useValue = null;
                     useValue = this.visitResult(ctxDataExpr);
                     if (useValue instanceof ParamDefinition_js_1.NumericValue) {
                         useValue = useValue.toNumber();
                     }
+                    segments.push([value, new helpers_js_1.UnitDimension(useValue)]);
                 }
-                if (useValue !== null) {
-                    this.setResult(ctx, [direction, new helpers_js_1.UnitDimension(useValue)]);
-                    return;
-                }
-            }
-            throw "Invalid direction or value for wire";
-        };
-        this.visitWire_expr = (ctx) => {
-            const wireAtomExpr = ctx.wire_atom_expr();
-            const segments = wireAtomExpr.map(wireSegment => {
-                return this.visitResult(wireSegment);
             });
             const newWire = this.getExecutor().addWire(segments);
             this.creationCtx.set(newWire, ctx);
         };
         this.visitPoint_expr = (ctx) => {
-            const ID = ctx.ID();
-            const ctxData = ctx.data_expr();
+            const ctxDataExpr = ctx.data_expr();
+            this.setResult(ctxDataExpr, { keepReference: true });
+            const result = this.visitResult(ctxDataExpr);
             let pointValue;
-            if (ctxData) {
-                const resultValue = this.visitResult(ctxData);
+            if (result.found) {
+                const resultValue = (0, utils_js_1.unwrapValue)(result);
                 if (typeof resultValue === 'string') {
                     pointValue = resultValue;
                 }
@@ -846,16 +788,11 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                     throw new utils_js_2.RuntimeExecutionError('Invalid value for point');
                 }
             }
-            else if (ID) {
-                pointValue = ID.getText();
+            else {
+                pointValue = result.name;
             }
             return this.getExecutor().addPoint(pointValue);
         };
-        this.visitProperty_set_expr = (ctx) => {
-            const result = this.visitResult(ctx.data_expr());
-            const resolvedProperty = this.visitResult(ctx.atom_expr());
-            this.getExecutor().setProperty(resolvedProperty, result);
-        };
         this.visitDouble_dot_property_set_expr = (ctx) => {
             const result = this.visitResult(ctx.data_expr());
             const propertyName = ctx.ID().getText();
@@ -874,14 +811,15 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             this.getExecutor().exitFrame(frameId);
         };
         this.visitNet_namespace_expr = (ctx) => {
-            let dataValue = null;
+            let dataValue;
             let netNamespace = null;
             const hasPlus = ctx.Addition();
             const ctxDataExpr = ctx.data_expr();
             if (ctxDataExpr) {
+                this.setResult(ctxDataExpr, { keepReference: true });
                 dataValue = this.visitResult(ctxDataExpr);
-                if (dataValue instanceof types_js_1.UndeclaredReference) {
-                    netNamespace = "/" + dataValue.reference.name;
+                if (!dataValue.found) {
+                    netNamespace = "/" + dataValue.name;
                 }
                 else if (typeof dataValue === "string") {
                     netNamespace = "/" + dataValue;
@@ -1008,7 +946,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             executor.popBreakContext();
         };
         this.visitAnnotation_comment_expr = (ctx) => {
-            const refdesID = ctx.ID().getText();
+            const refdesID = ctx.getText().replace('#=', '').trim();
             this.setCurrentComponentRefdes(refdesID);
         };
         this.visitPart_set_expr = (ctx) => {
@@ -1022,26 +960,21 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             (0, ComponentMatchConditions_js_1.applyPartConditions)(instances, paramKeys, partConditions);
         };
         this.visitPart_match_block = (ctx) => {
-            const results = ctx.part_sub_expr().map(ctxExpr => {
-                return this.visitResult(ctxExpr);
-            });
+            const results = ctx.part_sub_expr().reduce((accum, ctxExpr) => {
+                const result = this.visitResult(ctxExpr);
+                if (result !== undefined) {
+                    accum.push(result);
+                }
+                return accum;
+            }, []);
             this.setResult(ctx, results);
         };
         this.visitPart_sub_expr = (ctx) => {
-            const ctxForm1 = ctx.part_condition_expr();
-            const ctxForm2 = ctx.part_condition_key_only_expr();
-            const ctxForm3 = ctx.part_value_expr();
-            let result;
-            if (ctxForm1) {
-                result = this.visitResult(ctxForm1);
-            }
-            else if (ctxForm2) {
-                result = this.visitResult(ctxForm2);
-            }
-            else if (ctxForm3) {
-                result = this.visitResult(ctxForm3);
+            this.visitChildren(ctx);
+            const result = this.getResult(ctx.children[0]);
+            if (result !== undefined) {
+                this.setResult(ctx, result);
             }
-            this.setResult(ctx, result);
         };
         this.visitPart_set_key = (ctx) => {
             const ctxID = ctx.ID();
@@ -1073,10 +1006,17 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
         };
         this.visitPart_value_expr = (ctx) => {
             const key = this.visitResult(ctx.part_set_key());
-            const values = ctx.data_expr().map(ctxData => {
-                return this.visitResult(ctxData);
-            });
-            this.setResult(ctx, { key, endValue: values });
+            const ctxPartMatchBlock = ctx.part_match_block();
+            if (ctxPartMatchBlock) {
+                const children = this.visitResult(ctxPartMatchBlock);
+                this.setResult(ctx, { key, children });
+            }
+            else {
+                const values = ctx.data_expr().map(ctxData => {
+                    return this.visitResult(ctxData);
+                });
+                this.setResult(ctx, { key, endValue: values });
+            }
         };
         this.visitPart_condition_expr = (ctx) => {
             const allKeys = ctx._key_id.map(ctx => {
@@ -1116,14 +1056,6 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             });
             this.setResult(ctx, tmpKeyValues);
         };
-        this.visitPart_condition_key_only_expr = (ctx) => {
-            const key = this.visitResult(ctx.part_set_key());
-            const children = this.visitResult(ctx.part_match_block());
-            this.setResult(ctx, {
-                key,
-                children,
-            });
-        };
         this.pinTypes = [
             PinTypes_js_1.PinTypes.Any,
             PinTypes_js_1.PinTypes.IO,
@@ -1385,19 +1317,23 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             currentComponent.forceSaveRefdesAnnotation = forceSave;
         }
     }
-    async checkLibraryHasRefdesFile(filePath) {
+    getPathRefdesFile(filePath) {
+        const mainDir = this.environment.dirname(filePath);
+        const mainExt = this.environment.extname(filePath);
+        const mainBasename = this.environment.basename(filePath, mainExt);
+        return this.environment.join(mainDir, `${mainBasename}${globals_js_1.RefdesFileSuffix}`);
+    }
+    checkLibraryInRefdesFile(filePath) {
         if (this.filePathStack.length === 0) {
             return;
         }
-        const mainFilePath = this.environment.getAbsolutePath(this.filePathStack[0]);
-        const mainDir = this.environment.dirname(mainFilePath);
-        const mainExt = this.environment.extname(mainFilePath);
-        const mainBasename = this.environment.basename(mainFilePath, mainExt);
-        const refdesFilePath = this.environment.join(mainDir, `${mainBasename}${globals_js_1.RefdesFileSuffix}`);
-        const exists = await this.environment.exists(refdesFilePath);
+        const [baseFile] = this.filePathStack;
+        const mainDir = this.environment.dirname(baseFile);
+        const refdesFilePath = this.getPathRefdesFile(baseFile);
+        const exists = this.loadedFiles.has(refdesFilePath);
         if (exists) {
             this.log(`Main schematic has refdes file: ${refdesFilePath}`);
-            const fileData = await this.environment.readFile(refdesFilePath);
+            const fileData = this.loadedFiles.get(refdesFilePath);
             const jsonData = JSON.parse(fileData);
             const relativeLibraryPath = this.environment.relative(mainDir, filePath);
             const { libraries = [] } = jsonData;
@@ -1409,7 +1345,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                     for (const refdes in items) {
                         const val = items[refdes];
                         const parts = val.split(':');
-                        const key = this.getRefdesFileAnnotation(useFilePath, Number(parts[0]), Number(parts[1]), Number(parts[2]), Number(parts[3]));
+                        const key = this.getRefdesFileAnnotationKey(useFilePath, Number(parts[0]), Number(parts[1]), Number(parts[2]), Number(parts[3]));
                         this.refdesFileAnnotations.set(key, refdes);
                     }
                     break;