circuitscript 0.1.20 → 0.1.22

package/dist/esm/antlr/CircuitScriptVisitor.js

@@ -22,6 +22,7 @@ export class CircuitScriptVisitor extends AbstractParseTreeVisitor {
     visitAt_to_multiple_line_expr_to_pin;
     visitAt_block;
     visitAt_block_expressions;
+    visitAt_block_header;
     visitAt_block_pin_expr;
     visitAt_block_pin_expression_simple;
     visitAt_block_pin_expression_complex;
@@ -78,4 +79,5 @@ export class CircuitScriptVisitor extends AbstractParseTreeVisitor {
     visitElse_expr;
     visitWhile_expr;
     visitFor_expr;
+    visitAnnotation_comment_expr;
 }

package/dist/esm/environment.js

@@ -14,6 +14,7 @@ export class NodeScriptEnvironment {
     useModuleDirectoryPath = null;
     useDefaultLibsPath = null;
     globalCreateSVGWindow = null;
+    cachedVersion = null;
     supportedFonts = {
         'Arial': 'Arial.ttf',
     };
@@ -24,7 +25,20 @@ export class NodeScriptEnvironment {
         this.useDefaultLibsPath = path;
     }
     getPackageVersion() {
-        return TOOL_VERSION;
+        if (this.cachedVersion !== null) {
+            return this.cachedVersion;
+        }
+        try {
+            const packageJsonPath = path.join(this.getToolsPath(), '../', 'package.json');
+            const packageJsonContent = fs.readFileSync(packageJsonPath, 'utf-8');
+            const packageJson = JSON.parse(packageJsonContent);
+            this.cachedVersion = packageJson.version || TOOL_VERSION;
+            return this.cachedVersion;
+        }
+        catch (error) {
+            console.warn('Failed to read version from package.json, using fallback version:', error);
+            return TOOL_VERSION;
+        }
     }
     getModuleDirectory() {
         if (this.useModuleDirectoryPath !== null) {

package/dist/esm/execute.js

@@ -28,6 +28,7 @@ export class ExecutionContext {
     parentContext;
     componentAngleFollowsWire = true;
     warnings = [];
+    indexedStack = new Map();
     constructor(name, namespace, netNamespace, executionLevel = 0, scopeLevel = 0, silent = false, logger, warnings, parent) {
         this.name = name;
         this.namespace = namespace;
@@ -547,9 +548,39 @@ export class ExecutionContext {
         this.log('did not find block point');
         return null;
     }
+    getParentBreakContext() {
+        if (this.scope.breakStack.length > 0) {
+            return this.scope.breakStack[this.scope.breakStack.length - 1];
+        }
+        return null;
+    }
     addBreakContext(ctx) {
         this.log('add break context');
         this.scope.breakStack.push(ctx);
+        this.indexedStack.set(ctx, {
+            index: 0,
+            funcCallIndex: new Map(),
+        });
+    }
+    setBreakContextIndex(index) {
+        const latestCtx = this.scope.breakStack[this.scope.breakStack.length - 1];
+        if (latestCtx) {
+            const current = this.indexedStack.get(latestCtx);
+            this.indexedStack.set(latestCtx, {
+                ...current,
+                index,
+            });
+        }
+    }
+    resetBreakContextFunctionCalls() {
+        const latestCtx = this.scope.breakStack[this.scope.breakStack.length - 1];
+        if (latestCtx) {
+            const current = this.indexedStack.get(latestCtx);
+            this.indexedStack.set(latestCtx, {
+                index: current.index,
+                funcCallIndex: new Map(),
+            });
+        }
     }
     popBreakContext() {
         this.log('pop break context');
@@ -672,9 +703,18 @@ export class ExecutionContext {
             __runFunc = this.__functionCache.get(functionName);
         }
         if (__runFunc !== null) {
+            let functionCallIndex = -1;
+            if (!this.scope.functionCounter.has(__runFunc)) {
+                this.scope.functionCounter.set(__runFunc, 0);
+                functionCallIndex = 0;
+            }
+            else {
+                functionCallIndex = this.scope.functionCounter.get(__runFunc);
+            }
+            this.scope.functionCounter.set(__runFunc, functionCallIndex + 1);
             this.log(`call function '${functionName}'`);
             this.log(`net namespace: ${netNamespace}`);
-            const functionResult = __runFunc(functionParams, { netNamespace });
+            const functionResult = __runFunc(functionParams, { netNamespace, functionCallIndex });
             this.log(`done call function '${functionName}'`);
             return functionResult;
         }
@@ -687,6 +727,7 @@ export class ExecutionContext {
         const { currentComponent, currentPin, currentWireId } = this.scope;
         const tmpInstances = childScope.instances;
         const tmpNets = childScope.getNets();
+        const mergedInstances = [];
         for (const [instanceName, component] of tmpInstances) {
             const newInstanceName = `${namespace}.${instanceName}`;
             component.instanceName = newInstanceName;
@@ -699,6 +740,7 @@ export class ExecutionContext {
             else {
                 throw "Invalid instance name to merge into parent scope!";
             }
+            mergedInstances.push(component);
         }
         const childScopeUniqueNets = new Set(tmpNets.map(([, , net]) => net));
         childScopeUniqueNets.forEach(net => {
@@ -772,6 +814,7 @@ export class ExecutionContext {
             return accum;
         }, []);
         this.log('-- done merging scope --');
+        return mergedInstances;
     }
     addWire(segments) {
         if (this.scope.currentComponent === null) {
@@ -895,7 +938,7 @@ export class ExecutionContext {
             idName = this.scope.currentComponent.instanceName;
             if (this.scope.instances.has(idName)) {
                 const component = this.scope.instances.get(idName);
-                component.parameters.set(paramName, value);
+                component.setParam(paramName, value);
             }
             else if (this.scope.variables.has(idName)) {
                 throw "Not implemented yet!";

package/dist/esm/helpers.js

@@ -18,6 +18,7 @@ import { FrameParamKeys } from "./objects/Frame.js";
 import Big from "big.js";
 import { Logger } from "./logger.js";
 import { NetGraph } from "./graph.js";
+import { RefdesAnnotationVisitor } from "./RefdesAnnotationVisitor.js";
 export var JSModuleType;
 (function (JSModuleType) {
     JSModuleType["CommonJs"] = "cjs";
@@ -154,7 +155,7 @@ export async function renderScript(scriptData, outputPath, options) {
     return renderScriptCustom(scriptData, outputPath, options, parseHandlers);
 }
 export async function renderScriptCustom(scriptData, outputPath, options, parseHandlers) {
-    const { dumpNets = false, dumpData = false, showStats = false, environment } = options;
+    const { dumpNets = false, dumpData = false, showStats = false, environment, inputPath = null, updateSource = false, saveAnnotatedCopy = undefined, } = options;
     const errors = [];
     const onErrorHandler = (message, context, error) => {
         if (error && error instanceof RuntimeExecutionError) {
@@ -198,7 +199,7 @@ export async function renderScriptCustom(scriptData, outputPath, options, parseH
             mkdirSync(dumpDirectory);
         }
     }
-    const { tree, parser, parserTimeTaken, lexerTimeTaken, throwError } = await parseFileWithVisitor(visitor, scriptData);
+    const { tree, parser, tokens, parserTimeTaken, lexerTimeTaken, throwError } = await parseFileWithVisitor(visitor, scriptData);
     printWarnings(visitor.getWarnings());
     showStats && console.log('Lexing took:', lexerTimeTaken);
     showStats && console.log('Parsing took:', parserTimeTaken);
@@ -208,6 +209,22 @@ export async function renderScriptCustom(scriptData, outputPath, options, parseH
     catch (err) {
         throw new RenderError(`Error during component annotation: ${err}`, 'annotation');
     }
+    const componentLinks = visitor.getComponentCtxLinks();
+    const refdesVisitor = new RefdesAnnotationVisitor(true, scriptData, tokens, componentLinks);
+    await refdesVisitor.visitAsync(tree);
+    if (inputPath && (updateSource || saveAnnotatedCopy !== undefined)) {
+        let usePath = inputPath;
+        if (saveAnnotatedCopy === true) {
+            const dir = path.dirname(inputPath);
+            const ext = path.extname(inputPath);
+            const basename = path.basename(inputPath, ext);
+            usePath = path.join(dir, `${basename}.annotated${ext}`);
+        }
+        else if (typeof saveAnnotatedCopy === 'string') {
+            usePath = saveAnnotatedCopy;
+        }
+        writeFileSync(usePath, refdesVisitor.getOutput());
+    }
     if (dumpNets) {
         const nets = visitor.dumpNets();
         nets.forEach(item => console.log(item.join(" | ")));
@@ -326,8 +343,8 @@ export class ParseOutputHandler {
     afterRender = false;
 }
 export class KiCadNetListOutputHandler extends ParseOutputHandler {
-    beforeRender = true;
-    parse(visitor, outputPath, fileExtension) {
+    afterRender = true;
+    parse(visitor, outputPath, fileExtension, extra = null) {
         if (outputPath !== null && fileExtension === "net") {
             const { tree: kiCadNetList, missingFootprints } = generateKiCadNetList(visitor.getNetList());
             missingFootprints.forEach(entry => {

package/dist/esm/lexer.js

@@ -26,12 +26,14 @@ export class MainLexer extends CircuitScriptLexer {
             this.tokens = this.tokens.filter(function (val) {
                 return val.type !== CircuitScriptParser.EOF;
             });
-            this.emitToken(this.commonToken(CircuitScriptParser.NEWLINE, "\n"));
+            const fillerNewLine = this.commonToken(CircuitScriptParser.NEWLINE, "");
+            this.emitToken(fillerNewLine);
+            fillerNewLine.__skip = true;
             while (this.indents.length) {
                 this.emitToken(this.createDedent());
                 this.indents.pop();
             }
-            this.emitToken(this.commonToken(CircuitScriptParser.EOF, "<EOF>"));
+            this.emitToken(this.commonToken(CircuitScriptParser.EOF, ""));
         }
         const next = super.nextToken();
         return this.tokens.length ? this.tokens.shift() : next;
@@ -42,16 +44,24 @@ export class MainLexer extends CircuitScriptLexer {
     getCharIndex() {
         return this.inputStream.index;
     }
-    commonToken(type, text) {
-        const stop = this.getCharIndex() - 1;
-        const start = text.length ? stop - text.length + 1 : stop;
+    commonToken(type, text, start = -1, stop = -1) {
+        if (start === -1 && stop === -1) {
+            stop = this.getCharIndex() - 1;
+            start = text.length ? stop - text.length + 1 : stop;
+        }
         const token = CommonToken.fromSource([this, this.inputStream], type, 0, start, stop);
         let tokenTypeString = null;
         if (type === CircuitScriptParser.INDENT) {
-            tokenTypeString = "indent";
+            tokenTypeString = 'indent';
         }
         else if (type === CircuitScriptParser.DEDENT) {
-            tokenTypeString = "dedent";
+            tokenTypeString = 'dedent';
+        }
+        else if (type === CircuitScriptParser.NEWLINE) {
+            tokenTypeString = 'newline';
+        }
+        else if (type === CircuitScriptParser.EOF) {
+            tokenTypeString = 'EOF';
         }
         if (tokenTypeString !== null) {
             token.text = tokenTypeString;
@@ -89,7 +99,9 @@ export class MainLexer extends CircuitScriptLexer {
             this.skip();
         }
         else {
-            this.emitToken(this.commonToken(CircuitScriptParser.NEWLINE, newLine));
+            const start = this.getCharIndex() - this.text.length;
+            const stop = this.getCharIndex() - 1;
+            this.emitToken(this.commonToken(CircuitScriptParser.NEWLINE, newLine, start, start));
             const indent = this.getIndentationCount(spaces);
             const previous = this.indents.length ? this.indents[this.indents.length - 1] : 0;
             if (indent === previous) {
@@ -97,7 +109,7 @@ export class MainLexer extends CircuitScriptLexer {
             }
             else if (indent > previous) {
                 this.indents.push(indent);
-                this.emitToken(this.commonToken(CircuitScriptParser.INDENT, spaces));
+                this.emitToken(this.commonToken(CircuitScriptParser.INDENT, spaces, start + 1, stop));
             }
             else {
                 while (this.indents.length && this.indents[this.indents.length - 1] > indent) {

package/dist/esm/main.js

@@ -15,6 +15,8 @@ export default async function main() {
         .argument('[output path]', 'Output path')
         .option('-i, --input text <input text>', 'Input text directly')
         .option('-c, --current-directory <path>', 'Set current directory')
+        .option('-u, --update-source', 'Update source file with refdes annotation')
+        .option('-j, --annotated-path [file-path]', 'Save annotated source file at given path')
         .option('-w, --watch', 'Watch for file changes')
         .option('-n, --dump-nets', 'Dump out net information')
         .option('-d, --dump-data', 'Dump data during parsing')
@@ -62,11 +64,22 @@ export default async function main() {
         console.error("Error: No input provided");
         return;
     }
+    let updateSource = false;
+    if (options.updateSource !== undefined) {
+        updateSource = options.updateSource;
+    }
+    let saveAnnotatedCopyPath = undefined;
+    if (options.annotatedPath !== undefined) {
+        saveAnnotatedCopyPath = options.annotatedPath;
+    }
     const scriptOptions = {
         dumpNets,
         dumpData,
         showStats: options.stats,
         environment: env,
+        inputPath: inputFilePath,
+        updateSource,
+        saveAnnotatedCopy: saveAnnotatedCopyPath,
     };
     let outputPath = null;
     if (args.length > 0 && args[1]) {

package/dist/esm/objects/ClassComponent.js

@@ -29,6 +29,9 @@ export class ClassComponent {
     useWireOrientationAngle = true;
     didSetWireOrientationAngle = false;
     assignedRefDes = null;
+    placeHolderRefDes = null;
+    ctxReferences = [];
+    _creationIndex = -1;
     constructor(instanceName, numPins) {
         this.instanceName = instanceName;
         this.numPins = numPins;
@@ -108,7 +111,7 @@ export class ClassComponent {
             return this.parameters.get(key);
         }
         else {
-            throw 'Invalid parameter key';
+            throw 'Invalid parameter key: ' + key;
         }
     }
     toString() {

package/dist/esm/objects/ExecutionScope.js

@@ -6,6 +6,7 @@ export class ExecutionScope {
     nets = [];
     instances = new Map();
     functions = new Map();
+    functionCounter = new Map();
     variables = new Map();
     symbols = new Map();
     blockStack = new Map();

package/dist/esm/parser.js

@@ -35,6 +35,7 @@ export async function parseFileWithVisitor(visitor, data) {
     const parserTimeTaken = parserTimer.lap();
     return {
         tree, parser,
+        tokens,
         hasParseError: false,
         hasError: false,
         parserTimeTaken,

package/dist/esm/visitor.js

@@ -10,7 +10,9 @@ import { BaseVisitor } from './BaseVisitor.js';
 import { getPortType, RuntimeExecutionError } from './utils.js';
 import { UnitDimension } from './helpers.js';
 import { FrameParamKeys } from './objects/Frame.js';
+import { ComponentAnnotater } from './ComponentAnnotater.js';
 export class ParserVisitor extends BaseVisitor {
+    componentCreationIndex = 0;
     visitKeyword_assignment_expr = (ctx) => {
         const id = ctx.ID().getText();
         const value = this.visitResult(ctx.data_expr());
@@ -35,28 +37,53 @@ export class ParserVisitor extends BaseVisitor {
         }
         this.setResult(ctx, pinId);
     };
+    trackNewComponentCreated = (callback) => {
+        const preCreatedIndex = this.componentCreationIndex;
+        callback();
+        const postCreatedIndex = this.componentCreationIndex;
+        let creationFlag = false;
+        if (postCreatedIndex > preCreatedIndex) {
+            creationFlag = true;
+        }
+        return creationFlag;
+    };
     visitAdd_component_expr = (ctx) => {
-        const [component, pinValue] = this.visitResult(ctx.data_expr_with_assignment());
-        this.getExecutor().addComponentExisting(component, pinValue);
+        let refComponent;
+        const creationFlag = this.trackNewComponentCreated(() => {
+            const [component, pinValue] = this.visitResult(ctx.data_expr_with_assignment());
+            this.getExecutor().addComponentExisting(component, pinValue);
+            refComponent = component;
+        });
+        this.linkComponentToCtx(ctx, refComponent, creationFlag);
     };
     visitAt_component_expr = (ctx) => {
-        const [component, pin] = this.visitResult(ctx.component_select_expr());
-        this.getExecutor().atComponent(component, pin, {
-            addSequence: true
+        let refComponent;
+        const creationFlag = this.trackNewComponentCreated(() => {
+            const [component, pin] = this.visitResult(ctx.component_select_expr());
+            this.getExecutor().atComponent(component, pin, {
+                addSequence: true
+            });
+            refComponent = component;
         });
+        this.linkComponentToCtx(ctx, refComponent, creationFlag);
         return this.getExecutor().getCurrentPoint();
     };
     visitTo_component_expr = (ctx) => {
         ctx.component_select_expr().forEach(item => {
-            const [component, pin] = this.visitResult(item);
-            try {
-                this.getExecutor().toComponent(component, pin, {
-                    addSequence: true
-                });
-            }
-            catch (err) {
-                throw new RuntimeExecutionError(err.message, ctx);
-            }
+            let refComponent;
+            const creationFlag = this.trackNewComponentCreated(() => {
+                const [component, pin] = this.visitResult(item);
+                try {
+                    this.getExecutor().toComponent(component, pin, {
+                        addSequence: true
+                    });
+                    refComponent = component;
+                }
+                catch (err) {
+                    throw new RuntimeExecutionError(err.message, ctx);
+                }
+            });
+            this.linkComponentToCtx(item, refComponent, creationFlag);
         });
         return this.getExecutor().getCurrentPoint();
     };
@@ -327,6 +354,7 @@ export class ParserVisitor extends BaseVisitor {
         try {
             const createdComponent = this.getExecutor().createComponent(instanceName, pins, params, props);
             this.setResult(ctx, createdComponent);
+            createdComponent._creationIndex = this.componentCreationIndex++;
         }
         catch (error) {
             this.throwWithContext(ctx, error.message);
@@ -867,7 +895,28 @@ export class ParserVisitor extends BaseVisitor {
         const resolveNet = this.createNetResolver(this.executionStack);
         const resolveComponentPinNet = this.createComponentPinNetResolver(this.executionStack);
         const __runFunc = (passedInParameters, options) => {
-            const executionContextName = `${functionName}-${functionCounter['counter']}`;
+            const executor = this.getExecutor();
+            const parentBreakContext = executor.getParentBreakContext();
+            executor.addBreakContext(ctx);
+            let useIndex = -1;
+            if (parentBreakContext === null) {
+                useIndex = options.functionCallIndex;
+            }
+            else {
+                const parentEntry = executor.indexedStack.get(parentBreakContext);
+                const { funcCallIndex } = parentEntry;
+                if (!funcCallIndex.has(ctx)) {
+                    funcCallIndex.set(ctx, 0);
+                    useIndex = 0;
+                }
+                else {
+                    useIndex = funcCallIndex.get(ctx) + 1;
+                    funcCallIndex.set(ctx, useIndex);
+                }
+            }
+            executor.setBreakContextIndex(useIndex);
+            const functionCounterIndex = functionCounter['counter'];
+            const executionContextName = `${functionName}-${functionCounterIndex}`;
             const newExecutor = this.enterNewChildContext(executionStack, this.getExecutor(), executionContextName, options, funcDefinedParameters, passedInParameters);
             functionCounter['counter'] += 1;
             newExecutor.resolveNet = resolveNet;
@@ -875,7 +924,23 @@ export class ParserVisitor extends BaseVisitor {
             const returnValue = this.runExpressions(newExecutor, ctx.function_expr());
             const lastExecution = executionStack.pop();
             const nextLastExecution = executionStack[executionStack.length - 1];
-            nextLastExecution.mergeScope(lastExecution.scope, executionContextName);
+            const mergedComponents = nextLastExecution.mergeScope(lastExecution.scope, executionContextName);
+            const scope = this.getScope();
+            const indexedStack = [];
+            if (scope.breakStack.length > 0) {
+                const executor = this.getExecutor();
+                scope.breakStack.forEach(stackCtx => {
+                    const entry = executor.indexedStack.get(stackCtx);
+                    const { index } = entry;
+                    indexedStack.push([stackCtx, index]);
+                });
+                mergedComponents.forEach(component => {
+                    component.ctxReferences.forEach(ref => {
+                        ref.indexedStack = [...indexedStack, ...ref.indexedStack];
+                    });
+                });
+            }
+            executor.popBreakContext();
             return [lastExecution, returnValue];
         };
         this.getExecutor().createFunction(functionName, __runFunc, ctx, uniqueFunctionID);
@@ -919,10 +984,18 @@ export class ParserVisitor extends BaseVisitor {
         executor.log('end at block pin expressions');
         executor.atComponent(currentComponent, currentPin);
     };
+    visitAt_block_header = (ctx) => {
+        const ctxAtComponent = ctx.at_component_expr();
+        this.visit(ctxAtComponent);
+        const [currentComponent,] = this.getExecutor().getCurrentPoint();
+        this.componentCtxLinks.delete(ctxAtComponent);
+        this.componentCtxLinks.set(ctx, currentComponent);
+    };
     visitAt_block = (ctx) => {
         const executor = this.getExecutor();
         executor.log('entering at block');
-        this.visit(ctx.at_component_expr());
+        const ctxAtBlockComponent = ctx.at_block_header();
+        this.visit(ctxAtBlockComponent);
         const [currentComponent, currentPin] = executor.getCurrentPoint();
         executor.scope.scopeLevel += 1;
         ctx.at_block_expressions().forEach(expression => {
@@ -1082,10 +1155,14 @@ export class ParserVisitor extends BaseVisitor {
         const dataExpr = ctx.data_expr();
         let keepLooping = true;
         this.log('enter while loop');
-        this.getExecutor().addBreakContext(ctx);
+        const executor = this.getExecutor();
+        executor.addBreakContext(ctx);
+        let counter = 0;
         while (keepLooping) {
             const result = this.visitResult(dataExpr);
             if (result) {
+                executor.setBreakContextIndex(counter);
+                executor.resetBreakContextFunctionCalls();
                 this.visit(ctx.expressions_block());
                 keepLooping = true;
                 const currentResult = this.getResult(ctx) ?? {};
@@ -1100,6 +1177,7 @@ export class ParserVisitor extends BaseVisitor {
                         continueSignal: false
                     });
                 }
+                counter++;
             }
             else {
                 keepLooping = false;
@@ -1113,7 +1191,8 @@ export class ParserVisitor extends BaseVisitor {
         const forVariableNames = ctx.ID().map(item => item.getText());
         let listItems = this.visitResult(ctx.data_expr());
         listItems = unwrapValue(listItems);
-        this.getExecutor().addBreakContext(ctx);
+        const executor = this.getExecutor();
+        executor.addBreakContext(ctx);
         let keepLooping = true;
         let counter = 0;
         while (keepLooping) {
@@ -1125,6 +1204,8 @@ export class ParserVisitor extends BaseVisitor {
                 useValueArray.forEach((value, index) => {
                     this.getScope().setVariable(forVariableNames[index], value);
                 });
+                executor.setBreakContextIndex(counter);
+                executor.resetBreakContextFunctionCalls();
                 this.visit(ctx.expressions_block());
                 keepLooping = true;
                 const currentResult = this.getResult(ctx) ?? {};
@@ -1146,7 +1227,19 @@ export class ParserVisitor extends BaseVisitor {
                 keepLooping = false;
             }
         }
-        this.getExecutor().popBreakContext();
+        executor.popBreakContext();
+    };
+    visitAnnotation_comment_expr = (ctx) => {
+        const refdesID = ctx.ID().getText();
+        const currentComponent = this.getScope().currentComponent;
+        if (currentComponent !== null) {
+            if (refdesID.indexOf('_') === -1) {
+                currentComponent.setParam('refdes', refdesID);
+            }
+            else {
+                currentComponent.placeHolderRefDes = refdesID;
+            }
+        }
     };
     resolveDataExpr(data_expr) {
         const value = this.visitResult(data_expr);
@@ -1349,8 +1442,8 @@ export class ParserVisitor extends BaseVisitor {
                 continue;
             }
             if (instance.assignedRefDes === null) {
-                if (instance.parameters.has('refdes')) {
-                    const refdes = instance.parameters.get('refdes');
+                if (instance.hasParam('refdes')) {
+                    const refdes = instance.getParam('refdes');
                     if (refdes) {
                         instance.assignedRefDes = refdes;
                         annotater.trackRefDes(refdes);
@@ -1362,10 +1455,7 @@ export class ParserVisitor extends BaseVisitor {
             }
         }
         toAnnotate.forEach(instance => {
-            const useTypeProp = instance.typeProp ?? 'conn';
-            instance.typeProp === null
-                && this.log('Instance has no type:', instance.instanceName, ' assuming connector');
-            const newRefDes = annotater.getAnnotation(useTypeProp);
+            const newRefDes = annotater.getAnnotation(instance);
             if (newRefDes !== null) {
                 instance.assignedRefDes = newRefDes;
                 this.log(newRefDes, '-', instance.instanceName);
@@ -1449,7 +1539,7 @@ export class ParserVisitor extends BaseVisitor {
         return this.warnings;
     }
 }
-const ComponentRefDesPrefixes = {
+export const ComponentRefDesPrefixes = {
     res: 'R',
     cap: 'C',
     ind: 'L',
@@ -1460,48 +1550,6 @@ const ComponentRefDesPrefixes = {
     ic: 'U',
     '?': '?',
 };
-class ComponentAnnotater {
-    counter = {};
-    existingRefDes = [];
-    constructor() {
-        for (const key in ComponentRefDesPrefixes) {
-            this.counter[key] = 1;
-        }
-    }
-    getAnnotation(type) {
-        if (this.counter[type] === undefined && type.length <= 2) {
-            for (const [, value] of Object.entries(ComponentRefDesPrefixes)) {
-                if (value === type) {
-                    throw "Refdes prefix is already in use!";
-                }
-            }
-            if (ComponentRefDesPrefixes[type] === undefined) {
-                ComponentRefDesPrefixes[type] = type;
-                this.counter[type] = 1;
-            }
-        }
-        if (ComponentRefDesPrefixes[type] === undefined) {
-            return null;
-        }
-        let attempts = 100;
-        let proposedName = "";
-        while (attempts >= 0) {
-            proposedName = ComponentRefDesPrefixes[type] + this.counter[type];
-            this.counter[type]++;
-            if (this.existingRefDes.indexOf(proposedName) === -1) {
-                break;
-            }
-            attempts--;
-        }
-        if (attempts === 0) {
-            throw "Annotation failed!";
-        }
-        return proposedName;
-    }
-    trackRefDes(name) {
-        this.existingRefDes.push(name);
-    }
-}
 export class VisitorExecutionException {
     errorMessage;
     context;

package/dist/types/BaseVisitor.d.ts

@@ -21,6 +21,7 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyR
     printToConsole: boolean;
     acceptedDirections: Direction[];
     protected resultData: Map<ParserRuleContext, any>;
+    protected componentCtxLinks: Map<ParserRuleContext, ClassComponent>;
     pinTypesList: string[];
     onErrorHandler: OnErrorHandler | null;
     environment: NodeScriptEnvironment;
@@ -64,6 +65,8 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyR
     visitArrayIndexExpr: (ctx: ArrayIndexExprContext) => void;
     protected setResult(ctx: ParserRuleContext, value: any): void;
     protected getResult(ctx: ParserRuleContext): any;
+    protected linkComponentToCtx(ctx: ParserRuleContext, instance: ClassComponent, creationFlag?: boolean): void;
+    getComponentCtxLinks(): Map<ParserRuleContext, ClassComponent>;
     visitResult(ctx: ParserRuleContext): any;
     protected handleImportFile(name: string, throwErrors?: boolean, ctx?: ParserRuleContext | null): Promise<ImportFile>;
     visitRoundedBracketsExpr: (ctx: RoundedBracketsExprContext) => void;