circuitscript 0.1.31 → 0.1.33

package/dist/esm/regenerate-tests.js

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import { renderScript } from './helpers.js';
 import { NodeScriptEnvironment } from "./environment.js";
-const mainDir = './__tests__/renderData/';
+const mainDir = './__tests__/testData/renderData/';
 const env = new NodeScriptEnvironment();
 NodeScriptEnvironment.setInstance(env);
 async function regenerateTests(extra = "") {
@@ -9,7 +9,7 @@ async function regenerateTests(extra = "") {
     const cstFiles = [];
     const files = fs.readdirSync(mainDir);
     files.forEach(file => {
-        if (file.endsWith('.cst')) {
+        if (file.endsWith('.cst') && file.startsWith('script')) {
             cstFiles.push(file);
         }
     });
@@ -19,7 +19,7 @@ async function regenerateTests(extra = "") {
         const scriptData = fs.readFileSync(inputPath, { encoding: 'utf-8' });
         const outputPath = mainDir + 'svgs/' + file + extra + '.svg';
         env.setModuleDirectory(mainDir);
-        env.setDefaultLibsPath(mainDir + '../../libs/');
+        env.setDefaultLibsPath(mainDir + '../../../libs/');
         await renderScript(scriptData, outputPath, {
             dumpNets: false,
             dumpData: false,

package/dist/esm/render.js

@@ -36,10 +36,11 @@ export function renderSheetsToSVG(sheetFrames, logger) {
             const frameComponent = sheet.frame.frame.parameters
                 .get(FrameParamKeys.SheetType);
             if (frameComponent) {
-                if (frameComponent.displayProp === null) {
+                const frameComponentUnit = frameComponent.getUnit();
+                if (frameComponentUnit.displayProp === null) {
                     throw 'Invalid graphic object for sheet frame';
                 }
-                const frameRects = ExtractDrawingRects(frameComponent.displayProp) ?? [];
+                const frameRects = ExtractDrawingRects(frameComponentUnit.displayProp) ?? [];
                 let originalWidthMM = numeric(0);
                 let originalHeightMM = numeric(0);
                 let widthMM = numeric(0);
@@ -325,7 +326,8 @@ function drawSheetFrameBorder(frameGroup, frame) {
     const frameParams = frame.frame.parameters;
     if (frameParams.has(FrameParamKeys.SheetType)) {
         const frameComponent = frameParams.get(FrameParamKeys.SheetType);
-        const { displayProp = null } = frameComponent ?? {};
+        const frameComponentUnit = frameComponent.getUnit();
+        const { displayProp = null } = frameComponentUnit ?? {};
         if (displayProp) {
             const sheetFrameGroup = frameGroup.group();
             const symbol = new SymbolPlaceholder(displayProp);

package/dist/esm/rules-check/no-connect-on-connected-pin.js

@@ -8,25 +8,26 @@ export function RuleCheck_NoConnectOnConnectedPin(graph, nets) {
     const makeComponentPinHash = (instanceName, pin) => {
         return instanceName + '-' + pin.getHashValue();
     };
-    nets.forEach(item => {
-        const [component, pin, net] = item;
+    for (const [component, pin, net] of nets) {
         if (!netComponentPins.has(net)) {
             netComponentPins.set(net, []);
         }
         const items = netComponentPins.get(net);
+        const unit = component.getUnitForPin(pin);
         items.push([
-            component.instanceName,
+            unit.instanceName,
             pin
         ]);
         netComponentPins.set(net, items);
-        pinMapping.set(makeComponentPinHash(component.instanceName, pin), net);
-    });
-    allNodes.forEach(node => {
+        pinMapping.set(makeComponentPinHash(unit.instanceName, pin), net);
+    }
+    ;
+    for (const node of allNodes) {
         const nodeInfo = graph.node(node);
         if (nodeInfo[0] === RenderItemType.Component) {
             const { component } = nodeInfo[1];
             if (component.hasParam('no_connect')) {
-                const instanceName = component.instanceName;
+                const instanceName = component.getUnit().instanceName;
                 const edges = graph.nodeEdges(node);
                 const otherNodes = [];
                 edges.forEach(edge => {
@@ -72,6 +73,6 @@ export function RuleCheck_NoConnectOnConnectedPin(graph, nets) {
                 });
             }
         }
-    });
+    }
     return items;
 }

package/dist/esm/rules-check/rules.js

@@ -22,7 +22,7 @@ export function EvaluateERCRules(visitor, graph, nets) {
                         reportItems.push({
                             type,
                             start: token,
-                            message: `Unconnected pin ${item.pin} for component`
+                            message: `Unconnected pin: ${instance.assignedRefDes} pin ${item.pin}`
                         });
                     }
                 }
@@ -44,12 +44,17 @@ export function EvaluateERCRules(visitor, graph, nets) {
             case ERC_Rules.NoConnectOnConnectedPin:
                 {
                     const instance = item.instance;
+                    const { instance: targetComponent, pin: targetPin } = item.target;
+                    let extra = '';
+                    if (targetComponent && targetComponent.assignedRefDes) {
+                        extra = `: ${targetComponent.assignedRefDes} pin ${targetPin}`;
+                    }
                     const token = getComponentFirstCtxToken(instance);
                     if (token) {
                         reportItems.push({
                             type,
                             start: token,
-                            message: `No connect on connected pin`
+                            message: `No connect on connected pin${extra}`
                         });
                     }
                 }

package/dist/esm/rules-check/unconnected-pins.js

@@ -3,13 +3,15 @@ import { ERC_Rules } from "./rules.js";
 export function RuleCheck_UnconnectedPinsWires(graph) {
     const items = [];
     const allNodes = graph.nodes();
-    allNodes.forEach(node => {
+    for (const node of allNodes) {
         const nodeInfo = graph.node(node);
         if (nodeInfo[0] === RenderItemType.Component) {
-            const { component } = nodeInfo[1];
+            const renderComponent = nodeInfo[1];
+            const { component, unitId } = renderComponent;
             const edges = graph.nodeEdges(node);
-            const instanceName = component.instanceName;
-            const connectedPins = [];
+            const componentUnit = component.getUnit(unitId);
+            const instanceName = componentUnit.instanceName;
+            const connectedUnitPins = [];
             edges.forEach(edge => {
                 const edgeInfo = graph.edge(edge.v, edge.w);
                 let pin;
@@ -19,12 +21,12 @@ export function RuleCheck_UnconnectedPinsWires(graph) {
                 else if (edge.w === instanceName) {
                     pin = edgeInfo[3];
                 }
-                connectedPins.push(pin.getHashValue());
+                connectedUnitPins.push(pin.getHashValue());
             });
-            const pinIds = Array.from(component.pins.keys());
+            const pinIds = Array.from(componentUnit.pins.keys());
             pinIds.forEach(pinId => {
                 const hashValue = pinId.getHashValue();
-                if (connectedPins.indexOf(hashValue) === -1) {
+                if (connectedUnitPins.indexOf(hashValue) === -1) {
                     items.push({
                         type: ERC_Rules.UnconnectedPin,
                         instance: component,
@@ -43,6 +45,6 @@ export function RuleCheck_UnconnectedPinsWires(graph) {
                 });
             }
         }
-    });
+    }
     return items;
 }

package/dist/esm/utils.js

@@ -58,7 +58,8 @@ export function getBoundsSize(bounds) {
     };
 }
 export function getPortType(component) {
-    const drawingCommands = component.displayProp;
+    const targetUnit = component.getUnit();
+    const drawingCommands = targetUnit.displayProp;
     let foundPinType = null;
     const commands = drawingCommands.getCommands();
     commands.some(item => {

package/dist/esm/validate/SymbolValidatorVisitor.js

@@ -7,16 +7,6 @@ import { BaseVisitor } from "../BaseVisitor.js";
 import { BaseNamespace, 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);

package/dist/esm/visitor.js

@@ -3,7 +3,7 @@ import { NumberOperator, numeric, NumericValue, ParamDefinition } from './object
 import { PinDefinition, PinId, PinIdType } from './objects/PinDefinition.js';
 import { PinTypes } from './objects/PinTypes.js';
 import { AnyReference, DeclaredReference, TypeProps, UndeclaredReference } from './objects/types.js';
-import { BlockTypes, ComponentTypes, Delimiter1, FrameType, GlobalDocumentName, ModuleContainsKeyword, NoNetText, ParamKeys, ReferenceTypes, SymbolPinSide, ValidPinSides, WireAutoDirection } from './globals.js';
+import { BlockTypes, ComponentTypes, Delimiter1, FrameType, GlobalDocumentName, ModuleContainsKeyword, NoNetText, ParamKeys, RefdesFileSuffix, ReferenceTypes, SymbolPinSide, ValidPinSides, WireAutoDirection } from './globals.js';
 import { unwrapValue } from "./utils.js";
 import { PlaceHolderCommands, SymbolDrawingCommands } from './draw_symbols.js';
 import { BaseVisitor } from './BaseVisitor.js';
@@ -172,11 +172,117 @@ export class ParserVisitor extends BaseVisitor {
         if (ctxNotPathBlock) {
             this.visit(ctxNotPathBlock);
         }
+        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);
+            }
+        }
     };
     visitCreate_component_expr = (ctx) => {
         const scope = this.getScope();
+        scope.setOnPropertyHandler(this.createComponentPropertyValidator());
+        scope.enterContext(ctx);
+        ctx.property_expr().forEach(item => {
+            this.visitResult(item);
+        });
+        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);
+        if (params.length > 0) {
+            const firstParam = params[0];
+            const paramValue = firstParam.paramValue;
+            let appendValue = paramValue.toString();
+            if (paramValue instanceof NumericValue) {
+                appendValue = paramValue.value;
+            }
+            instanceName += `${Delimiter1}${appendValue}`;
+        }
+        const typeProp = properties.get('type') ?? null;
+        const copy = properties.get('copy') ?? false;
+        const unitDefinitions = this.extractComponentUnitProperties(properties, typeProp);
+        const props = {
+            type: typeProp,
+            copy,
+            units: unitDefinitions
+        };
+        try {
+            const createdComponent = this.getExecutor().createComponent(instanceName, [], params, props);
+            this.setResult(ctx, createdComponent);
+            createdComponent._creationIndex = this.componentCreationIndex++;
+        }
+        catch (error) {
+            this.throwWithContext(ctx, error.message);
+        }
+    };
+    extractComponentUnitDefinition(properties, typeProp = null, lastNumericPinId = 0) {
+        const width = properties.get('width') ?? null;
+        const height = properties.get('height') ?? null;
+        const angle = properties.get(ParamKeys.angle) ?? null;
+        const followWireOrientation = properties.get('followWireOrientation') ?? true;
+        const arrange = properties.get('arrange') ?? null;
+        const display = properties.get('display') ?? null;
+        const suffix = properties.get('suffix') ?? null;
+        let pins = [];
+        if (display !== null && arrange === null && typeProp !== TypeProps.Graphic) {
+            const drawCommands = display.getCommands();
+            drawCommands.forEach(command => {
+                const [commandValue,] = command;
+                if (commandValue === PlaceHolderCommands.vpin
+                    || commandValue === PlaceHolderCommands.hpin
+                    || commandValue === PlaceHolderCommands.pin) {
+                    const id = PinId.from(command[1][0]);
+                    const pinType = id.getType();
+                    const pinName = id.toString();
+                    pins.push(new PinDefinition(id, pinType, pinName, PinTypes.Any));
+                }
+            });
+        }
+        else {
+            pins = this.extractPinDefintion(properties.get('pins'), lastNumericPinId);
+        }
+        return {
+            width,
+            height,
+            angle,
+            followWireOrientation,
+            display, arrange,
+            pins,
+            suffix
+        };
+    }
+    extractComponentUnitProperties(properties, typeProp) {
+        let lastNumericPinId = 0;
+        const unitsProperties = [];
+        for (const [key, value] of properties) {
+            if (key.split(':')[0] === 'unit') {
+                const unitDef = this.extractComponentUnitDefinition(value, typeProp, lastNumericPinId);
+                unitDef.pins.forEach(pin => {
+                    if (pin.id.isNumeric()) {
+                        lastNumericPinId = Math.max(lastNumericPinId, pin.id.getValue());
+                    }
+                });
+                unitsProperties.push([key, unitDef]);
+            }
+        }
+        if (unitsProperties.length === 0) {
+            unitsProperties.push(['unit',
+                this.extractComponentUnitDefinition(properties, typeProp)]);
+        }
+        return unitsProperties;
+    }
+    createComponentPropertyValidator() {
         const definedPinIds = [];
         const arrangedPinIds = [];
+        let didDefineArrangeProp = false;
+        let didDefineDisplayProp = false;
         const checkPinExistsAndNotDuplicated = (pinId, ctx) => {
             if (definedPinIds.indexOf(pinId) === -1) {
                 this.warnings.push({
@@ -191,9 +297,7 @@ export class ParserVisitor extends BaseVisitor {
             }
             arrangedPinIds.push(pinId);
         };
-        let didDefineArrangeProp = false;
-        let didDefineDisplayProp = false;
-        scope.setOnPropertyHandler((path, value, ctx) => {
+        return (path, value, ctx) => {
             if (path.length === 1) {
                 const [, keyName] = path[0];
                 switch (keyName) {
@@ -302,76 +406,8 @@ export class ParserVisitor extends BaseVisitor {
                     }
                 }
             }
-        });
-        scope.enterContext(ctx);
-        ctx.property_expr().forEach(item => {
-            this.visitResult(item);
-        });
-        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);
-        if (params.length > 0) {
-            const firstParam = params[0];
-            const paramValue = firstParam.paramValue;
-            let appendValue = paramValue.toString();
-            if (paramValue instanceof NumericValue) {
-                appendValue = paramValue.value;
-            }
-            instanceName += `${Delimiter1}${appendValue}`;
-        }
-        const arrangeProp = properties.has('arrange') ?
-            properties.get('arrange') : null;
-        const displayProp = properties.has('display') ?
-            properties.get('display') : null;
-        const typeProp = properties.has('type') ?
-            properties.get('type') : null;
-        const copy = properties.has('copy') ?
-            properties.get('copy') : false;
-        const width = properties.has('width') ?
-            properties.get('width') : null;
-        const height = properties.has('height') ?
-            properties.get('height') : null;
-        const angle = properties.has(ParamKeys.angle) ?
-            properties.get(ParamKeys.angle) : null;
-        const followWireOrientation = properties.has('followWireOrientation') ?
-            properties.get('followWireOrientation') : true;
-        let pins = [];
-        if (displayProp !== null && arrangeProp === null
-            && typeProp !== TypeProps.Graphic) {
-            const drawCommands = displayProp.getCommands();
-            drawCommands.forEach(command => {
-                const [commandValue,] = command;
-                if (commandValue === PlaceHolderCommands.vpin
-                    || commandValue === PlaceHolderCommands.hpin
-                    || commandValue === PlaceHolderCommands.pin) {
-                    const id = PinId.from(command[1][0]);
-                    const pinType = id.getType();
-                    const pinName = id.toString();
-                    pins.push(new PinDefinition(id, pinType, pinName, PinTypes.Any));
-                }
-            });
-        }
-        else {
-            pins = this.parseCreateComponentPins(properties.get('pins'));
-        }
-        const props = {
-            arrange: arrangeProp,
-            display: displayProp,
-            type: typeProp, width, height, copy,
-            angle, followWireOrientation
         };
-        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);
-        }
-    };
+    }
     visitCreate_graphic_expr = (ctx) => {
         const ctxId = ctx.ID();
         const paramIds = [];
@@ -506,19 +542,18 @@ export class ParserVisitor extends BaseVisitor {
             return new PinDefinition(index + 1, PinIdType.Int, portName, PinTypes.Any);
         });
         const arrange = this.getArrangePropFromModulePorts(modulePorts, nameToPinId);
-        const width = properties.has('width') ?
-            properties.get('width') : null;
-        const height = properties.has('height') ?
-            properties.get('height') : null;
+        const unitProperties = this.extractComponentUnitProperties(properties, TypeProps.Module);
+        const firstUnitDef = unitProperties[0][1];
+        firstUnitDef.pins = tmpPorts;
+        firstUnitDef.arrange = arrange;
         const blankParams = [];
         const props = {
-            arrange, width, height,
             copy: false,
-            followWireOrientation: true,
+            units: unitProperties,
         };
         const moduleInstanceName = this.getExecutor().getUniqueInstanceName();
         const moduleComponent = this.getExecutor().createComponent(moduleInstanceName, tmpPorts, blankParams, props, true);
-        moduleComponent.typeProp = ComponentTypes.module;
+        moduleComponent.typeProp = TypeProps.Module;
         const ctxPropertyBlock = ctx.property_block_expr();
         if (ctxPropertyBlock) {
             const [firstBlock] = ctxPropertyBlock;
@@ -541,6 +576,10 @@ export class ParserVisitor extends BaseVisitor {
     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);
@@ -635,6 +674,7 @@ export class ParserVisitor extends BaseVisitor {
             dataResult = this.getExecutor().copyComponent(dataResult);
         }
         if (dataResult && dataResult instanceof ClassComponent) {
+            const defaultUnit = dataResult.getUnit();
             const modifiers = ctx.component_modifier_expr();
             modifiers.forEach(modifier => {
                 const modifierText = modifier.ID(0).getText();
@@ -651,23 +691,23 @@ export class ParserVisitor extends BaseVisitor {
                 if (modifierText === ParamKeys.flip) {
                     const flipValue = result;
                     if (flipValue.indexOf('x') !== -1) {
-                        dataResult.setParam(ParamKeys.flipX, 1);
+                        defaultUnit.setParam(ParamKeys.flipX, numeric(1));
                         shouldIgnoreWireOrientation = true;
                     }
                     if (flipValue.indexOf('y') !== -1) {
-                        dataResult.setParam(ParamKeys.flipY, 1);
+                        defaultUnit.setParam(ParamKeys.flipY, numeric(1));
                         shouldIgnoreWireOrientation = true;
                     }
                 }
                 else if (modifierText === ParamKeys.angle) {
-                    dataResult.setParam(ParamKeys.angle, result);
+                    defaultUnit.setParam(ParamKeys.angle, result);
                     shouldIgnoreWireOrientation = true;
                 }
                 else if (modifierText === 'anchor') {
                     dataResult.setParam('anchor', result);
                 }
                 if (shouldIgnoreWireOrientation) {
-                    dataResult.useWireOrientationAngle = false;
+                    defaultUnit.useWireOrientationAngle = false;
                 }
             });
         }
@@ -1206,17 +1246,21 @@ export class ParserVisitor extends BaseVisitor {
         }
         executor.popBreakContext();
     };
-    visitAnnotation_comment_expr = (ctx) => {
-        const refdesID = ctx.ID().getText();
+    setCurrentComponentRefdes(refdesValue, forceSave = false) {
         const currentComponent = this.getScope().currentComponent;
         if (currentComponent !== null) {
-            if (refdesID.indexOf('_') === -1) {
-                currentComponent.setParam('refdes', refdesID);
+            if (refdesValue.indexOf('_') === -1) {
+                currentComponent.setParam('refdes', refdesValue);
             }
             else {
-                currentComponent.placeHolderRefDes = refdesID;
+                currentComponent.placeHolderRefDes = refdesValue;
             }
+            currentComponent.forceSaveRefdesAnnotation = forceSave;
         }
+    }
+    visitAnnotation_comment_expr = (ctx) => {
+        const refdesID = ctx.ID().getText();
+        this.setCurrentComponentRefdes(refdesID);
     };
     visitPart_set_expr = (ctx) => {
         const paramKeys = ctx.data_expr().map(ctx => {
@@ -1331,6 +1375,28 @@ export class ParserVisitor extends BaseVisitor {
             children,
         });
     };
+    async checkModuleHasRefdesFile(filePath) {
+        const dir = this.environment.dirname(filePath);
+        const ext = this.environment.extname(filePath);
+        const basename = this.environment.basename(filePath, ext);
+        const annotatedFilePath = this.environment.join(dir, `${basename}${RefdesFileSuffix}`);
+        const exists = await this.environment.exists(annotatedFilePath);
+        if (exists) {
+            this.log(`Import has refdes file: ${annotatedFilePath}`);
+            const fileData = await this.environment.readFile(annotatedFilePath);
+            const jsonData = JSON.parse(fileData);
+            const baseFilePath = this.environment.getAbsolutePath(this.filePathStack[0]);
+            const basePathDirectory = this.environment.dirname(baseFilePath);
+            const { file, items } = jsonData;
+            for (const item of items) {
+                const parts = item.split(':');
+                const refdes = parts[4];
+                const useFilePath = this.environment.join(basePathDirectory, file);
+                const key = this.getRefdesFileAnnotation(useFilePath, Number(parts[0]), Number(parts[1]), Number(parts[2]), Number(parts[3]));
+                this.refdesFileAnnotations.set(key, refdes);
+            }
+        }
+    }
     resolveDataExpr(data_expr) {
         const value = this.visitResult(data_expr);
         if (value instanceof UndeclaredReference) {
@@ -1357,13 +1423,13 @@ export class ParserVisitor extends BaseVisitor {
         PinTypes.Output,
         PinTypes.Power,
     ];
-    parseCreateComponentPins(pinData) {
+    extractPinDefintion(pinData, lastNumericPinId = 0) {
         const pins = [];
         if (pinData instanceof NumericValue) {
             const tmpMap = new Map();
             const lastPin = pinData.toNumber();
             for (let i = 0; i < lastPin; i++) {
-                const pinId = i + 1;
+                const pinId = lastNumericPinId + i + 1;
                 tmpMap.set(pinId, numeric(pinId));
             }
             pinData = tmpMap;
@@ -1536,6 +1602,7 @@ export class ParserVisitor extends BaseVisitor {
                     const refdes = instance.getParam('refdes');
                     if (refdes) {
                         instance.assignedRefDes = refdes;
+                        this.setComponentUnitRefdesSuffix(instance);
                         annotater.trackRefDes(refdes);
                         this.log(refdes, '-', instance.instanceName);
                         continue;
@@ -1549,6 +1616,7 @@ export class ParserVisitor extends BaseVisitor {
             if (newRefDes !== null) {
                 instance.assignedRefDes = newRefDes;
                 this.log(newRefDes, '-', instance.instanceName);
+                this.setComponentUnitRefdesSuffix(instance);
             }
             else {
                 this.log('Failed to annotate:', instance.instanceName);
@@ -1559,6 +1627,24 @@ export class ParserVisitor extends BaseVisitor {
         this.renameNetsWithRefdes();
         this.log('===== rename nets done =====');
     }
+    setComponentUnitRefdesSuffix(instance) {
+        if (instance.assignedRefDes) {
+            const { units } = instance;
+            if (units.length > 1) {
+                units.forEach((unit, index) => {
+                    let useRefdes = String.fromCharCode("A".charCodeAt(0) + index);
+                    if (unit.suffix !== null) {
+                        useRefdes = unit.suffix;
+                    }
+                    unit.refdesSuffix = useRefdes;
+                });
+            }
+            else {
+                const [firstUnit] = units;
+                firstUnit.refdesSuffix = '';
+            }
+        }
+    }
     renameNetsWithRefdes() {
         const nets = this.getScope().getNets();
         const seenNets = [];
@@ -1617,10 +1703,17 @@ export class ParserVisitor extends BaseVisitor {
     }
     getPropertyExprList(items) {
         const properties = new Map();
+        const keyCounter = new Map();
         items.forEach((item) => {
             const result = this.visitResult(item);
             for (const [key, value] of result) {
-                properties.set(key, value);
+                let useKey = key;
+                const counterValue = keyCounter.get(key) ?? 0;
+                keyCounter.set(key, counterValue + 1);
+                if (counterValue > 0) {
+                    useKey = key + ':' + counterValue;
+                }
+                properties.set(useKey, value);
             }
         });
         return properties;

package/dist/types/BaseVisitor.d.ts

@@ -5,7 +5,7 @@ import { Logger } from "./logger.js";
 import { ClassComponent } from "./objects/ClassComponent.js";
 import { Net } from "./objects/Net.js";
 import { CallableParameter, ComplexType, Direction, FunctionDefinedParameter, AnyReference, ImportedModule, NewContextOptions, ImportFunctionHandling as ImportFunctionHandling } from "./objects/types.js";
-import { ParserRuleContext } from 'antlr4ng';
+import { CommonTokenStream, ParserRuleContext } from 'antlr4ng';
 import { ExecutionWarning } from "./utils.js";
 import { BaseError } from './utils.js';
 import { ExecutionScope } from './objects/ExecutionScope.js';
@@ -14,6 +14,7 @@ import { PinId } from './objects/PinDefinition.js';
 export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyReference | any> {
     startingContext: ExecutionContext;
     executionStack: ExecutionContext[];
+    filePathStack: string[];
     silent: boolean;
     logger: Logger;
     printStream: string[];
@@ -27,10 +28,8 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyR
     environment: NodeScriptEnvironment;
     protected importedFiles: ImportFile[];
     protected warnings: ExecutionWarning[];
-    onImportFile: (visitor: BaseVisitor, filePath: string, fileData: string, onErrorHandler: OnErrorHandler) => Promise<{
-        hasError: boolean;
-        hasParseError: boolean;
-    }>;
+    onImportFile: (visitor: BaseVisitor, filePath: string, fileData: string, onErrorHandler: OnErrorHandler) => Promise<ImportFileResult>;
+    refdesFileAnnotations: Map<string, string>;
     constructor(silent: boolean | undefined, onErrorHandler: OnErrorHandler | null | undefined, environment: NodeScriptEnvironment);
     getExecutor(): ExecutionContext;
     getScope(): ExecutionScope;
@@ -75,6 +74,8 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyR
     getComponentCtxLinks(): Map<ParserRuleContext, ClassComponent>;
     visitResult(ctx: ParserRuleContext): any;
     protected handleImportFile(name: string, importHandling: ImportFunctionHandling, throwErrors?: boolean, ctx?: ParserRuleContext | null, specificImports?: string[]): Promise<ImportFile>;
+    checkModuleHasRefdesFile(filePath: string): Promise<void>;
+    getRefdesFileAnnotation(filePath: string, startLine: number, startColumn: number, stopLine: number, stopColumn: number): string;
     visitRoundedBracketsExpr: (ctx: RoundedBracketsExprContext) => void;
     protected setupDefinedParameters(funcDefinedParameters: FunctionDefinedParameter[], passedInParameters: CallableParameter[], executor: ExecutionContext): void;
     protected runExpressions(executor: ExecutionContext, expressions: ExpressionContext[] | Function_exprContext[]): ComplexType;
@@ -88,6 +89,9 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyR
     protected validateString(value: any, context: ParserRuleContext): void;
     protected validateBoolean(value: any, context: ParserRuleContext): void;
     protected validateNumeric(value: any, context: ParserRuleContext): void;
+    enterFile(filePath: string): void;
+    exitFile(): void;
+    getCurrentFile(): string;
 }
 export type OnErrorHandler = (message: string, context: ParserRuleContext, e?: any) => void;
 type ImportFile = {
@@ -97,4 +101,10 @@ type ImportFile = {
     pathExists: boolean;
     importedModule: ImportedModule;
 };
+export type ImportFileResult = {
+    hasError: boolean;
+    hasParseError: boolean;
+    tree: ScriptContext;
+    tokens: CommonTokenStream;
+};
 export {};