circuitscript 0.3.2 → 0.4.1

package/dist/cjs/BaseVisitor.js

@@ -3,12 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseVisitor = void 0;
 const big_js_1 = require("big.js");
 const CircuitScriptParser_js_1 = require("./antlr/CircuitScriptParser.js");
-const CircuitScriptVisitor_js_1 = require("./antlr/CircuitScriptVisitor.js");
+const CircuitScriptParserVisitor_js_1 = require("./antlr/CircuitScriptParserVisitor.js");
 const execute_js_1 = require("./execute.js");
 const logger_js_1 = require("./logger.js");
 const ClassComponent_js_1 = require("./objects/ClassComponent.js");
 const ParamDefinition_js_1 = require("./objects/ParamDefinition.js");
-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");
@@ -16,7 +15,12 @@ const builtinMethods_js_1 = require("./builtinMethods.js");
 const utils_js_2 = require("./utils.js");
 const ExecutionScope_js_1 = require("./objects/ExecutionScope.js");
 const PinDefinition_js_1 = require("./objects/PinDefinition.js");
-class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
+const hash_js_1 = require("./cache/hash.js");
+const storage_js_1 = require("./cache/storage.js");
+const serializer_js_1 = require("./cache/serializer.js");
+const deserializer_js_1 = require("./cache/deserializer.js");
+const importResolver_js_1 = require("./importResolver.js");
+class BaseVisitor extends CircuitScriptParserVisitor_js_1.CircuitScriptParserVisitor {
     constructor(silent = false, onErrorHandler = null, environment) {
         super();
         this.filePathStack = [];
@@ -28,25 +32,22 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
             types_js_1.Direction.Right, types_js_1.Direction.Left];
         this.resultData = new Map;
         this.componentCtxLinks = new Map;
-        this.pinTypesList = [
-            PinTypes_js_1.PinTypes.Any,
-            PinTypes_js_1.PinTypes.Input,
-            PinTypes_js_1.PinTypes.Output,
-            PinTypes_js_1.PinTypes.IO,
-            PinTypes_js_1.PinTypes.Power,
-        ];
         this.onErrorHandler = null;
         this.importedFiles = [];
         this.warnings = [];
-        this.onImportFile = async (visitor, filePath, fileData, onErrorHandler) => {
+        this.loadedFiles = new Map();
+        this.enableCacheImports = true;
+        this.enableCachedImportsRead = false || this.enableCacheImports;
+        this.enableCachedImportsWrite = false || this.enableCacheImports;
+        this.onImportFile = (visitor, filePath, fileData, onErrorHandler, fileLineOffset) => {
             throw "Import file not implemented";
         };
         this.refdesFileAnnotations = new Map();
-        this.visitScript = async (ctx) => {
+        this.visitScript = (ctx) => {
             this.log('===', 'start', '===');
             this.allowParseImports = true;
             for (const ctxImport of ctx.import_expr()) {
-                await this.visit(ctxImport);
+                this.visit(ctxImport);
             }
             this.allowParseImports = false;
             const result = this.runExpressions(this.getExecutor(), ctx.expression());
@@ -54,148 +55,225 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
             this.getExecutor().closeOpenPathBlocks();
             this.log('===', 'end', '===');
         };
-        this.visitImport_simple = async (ctx) => {
-            await this.importCommon(ctx, types_js_1.ImportFunctionHandling.AllWithNamespace);
+        this.visitImport_simple = (ctx) => {
+            this.importCommon(ctx, types_js_1.ImportFunctionHandling.AllWithNamespace);
         };
-        this.visitImport_all_simple = async (ctx) => {
-            await this.importCommon(ctx, types_js_1.ImportFunctionHandling.AllMergeIntoNamespace);
+        this.visitImport_specific_or_all = (ctx) => {
+            let importType = types_js_1.ImportFunctionHandling.SpecificMergeIntoNamespace;
+            if (ctx._all) {
+                importType = types_js_1.ImportFunctionHandling.AllMergeIntoNamespace;
+            }
+            this.importCommon(ctx, importType);
         };
-        this.visitImport_specific = async (ctx) => {
-            await this.importCommon(ctx, types_js_1.ImportFunctionHandling.SpecificMergeIntoNamespace);
+        this.visitCallableExpr = (ctx) => {
+            this.passResult(ctx, ctx.callable_expr());
+        };
+        this.visitCallable_expr = (ctx) => {
+            const ctxParams = this.getResult(ctx);
+            const { keepReference = false } = ctxParams ?? {};
+            const executor = this.getExecutor();
+            let passedNetNamespace = null;
+            const netNameSpaceExpr = ctx.net_namespace_expr();
+            if (netNameSpaceExpr) {
+                passedNetNamespace = this.visitResult(netNameSpaceExpr);
+            }
+            const firstId = ctx.ID(0);
+            const atomId = firstId.getText();
+            let currentReference;
+            if (globals_js_1.PinTypesList.indexOf(atomId) !== -1 && ctx.trailer().length === 0) {
+                currentReference = new types_js_1.AnyReference({
+                    found: true,
+                    value: atomId,
+                    type: globals_js_1.ReferenceTypes.pinType,
+                });
+            }
+            else {
+                this.log('resolve variable ctx: ' + ctx.getText(), 'atomId', atomId);
+                currentReference = executor.resolveVariable(this.executionStack, atomId);
+                this.log('reference:', currentReference.name, 'found:', currentReference.found);
+            }
+            if (currentReference !== undefined && currentReference.found) {
+                ctx.trailer().forEach(ctxTrailer => {
+                    this.setResult(ctxTrailer, {
+                        reference: currentReference,
+                        netNamespace: passedNetNamespace
+                    });
+                    currentReference = this.visitResult(ctxTrailer);
+                });
+            }
+            let resultValue = currentReference;
+            if (!keepReference) {
+                if (currentReference.type !== globals_js_1.ReferenceTypes.pinType) {
+                    resultValue = (0, utils_js_1.unwrapValue)(resultValue);
+                }
+            }
+            this.setResult(ctx, resultValue);
+            this.log2('atom resolved: ' + ctx.getText() + ' -> ' + currentReference);
+        };
+        this.visitTrailer = (ctx) => {
+            const { reference, netNamespace } = this.getResult(ctx);
+            const ctxLParam = ctx.LParen();
+            const ctxID = ctx.ID();
+            const ctxDataExpr = ctx.data_expr();
+            const useValue = reference.value;
+            let nextReference;
+            if (ctxID) {
+                reference.trailers.push(ctxID.getText());
+                const useRootValue = reference.rootValue ?? reference.value;
+                const useTrailerIndex = reference.trailerIndex ?? 0;
+                nextReference = this.getExecutor().resolveTrailers(reference.type, useRootValue, reference.trailers);
+                nextReference.name =
+                    [reference.name,
+                        ...reference.trailers.slice(useTrailerIndex)].join('.');
+            }
+            else if (ctxDataExpr) {
+                const arrayIndex = this.visitResult(ctxDataExpr);
+                if (arrayIndex instanceof ParamDefinition_js_1.NumericValue) {
+                    const arrayIndexValue = arrayIndex.toNumber();
+                    const foundValue = useValue[arrayIndexValue];
+                    const refType = foundValue instanceof ClassComponent_js_1.ClassComponent
+                        ? globals_js_1.ReferenceTypes.instance : globals_js_1.ReferenceTypes.variable;
+                    nextReference = new types_js_1.AnyReference({
+                        found: true,
+                        type: refType,
+                        value: foundValue,
+                        trailers: [[globals_js_1.TrailerArrayIndex, arrayIndexValue]],
+                        rootValue: useValue
+                    });
+                }
+            }
+            else if (ctxLParam) {
+                nextReference = this.handleFunctionCall(reference, netNamespace, ctx);
+            }
+            this.setResult(ctx, nextReference);
         };
         this.visitAssignment_expr = (ctx) => {
-            const ctxAtom = ctx.atom_expr();
-            const ctxFuncCallRef = ctx.function_call_expr();
-            let leftSideReference;
-            let lhsCtx;
-            if (ctxAtom) {
-                leftSideReference = this.getReference(ctx.atom_expr());
-                lhsCtx = ctxAtom;
-            }
-            else if (ctxFuncCallRef) {
-                this.setResult(ctxFuncCallRef, { keepReference: true });
-                leftSideReference = this.visitResult(ctxFuncCallRef);
-                lhsCtx = ctxFuncCallRef;
-            }
-            const rhsCtx = ctx.data_expr();
-            const rhsCtxResult = this.visitResult(rhsCtx);
-            if ((0, utils_js_1.isReference)(rhsCtxResult) && !rhsCtxResult.found) {
-                this.throwWithContext(rhsCtx, rhsCtx.getText() + ' is not defined');
-            }
-            const rhsValue = (0, utils_js_1.unwrapValue)(rhsCtxResult);
-            const trailers = leftSideReference.trailers ?? [];
-            const sequenceParts = [];
-            if (trailers.length === 0) {
-                this.getScope().setVariable(leftSideReference.name, rhsValue);
-                let itemType = '';
-                if (rhsValue instanceof ClassComponent_js_1.ClassComponent) {
-                    itemType = globals_js_1.ReferenceTypes.instance;
-                    this.log2(`assigned '${leftSideReference.name}' to ClassComponent`);
+            if (ctx.Assign()) {
+                const lhsCtx = ctx.callable_expr();
+                this.setResult(lhsCtx, { keepReference: true });
+                const leftSideReference = this.visitResult(lhsCtx);
+                const rhsCtx = ctx.data_expr();
+                const rhsCtxResult = this.visitResult(rhsCtx);
+                if ((0, utils_js_1.isReference)(rhsCtxResult) && !rhsCtxResult.found) {
+                    this.throwWithContext(rhsCtx, rhsCtx.getText() + ' is not defined');
                 }
-                else {
-                    itemType = globals_js_1.ReferenceTypes.variable;
+                const rhsValue = (0, utils_js_1.unwrapValue)(rhsCtxResult);
+                const { trailers = [] } = leftSideReference;
+                const sequenceParts = [];
+                if (trailers.length === 0) {
                     this.getScope().setVariable(leftSideReference.name, rhsValue);
-                    this.log2(`assigned variable ${leftSideReference.name} to ${rhsValue}`);
+                    let itemType = '';
+                    if (rhsValue instanceof ClassComponent_js_1.ClassComponent) {
+                        itemType = globals_js_1.ReferenceTypes.instance;
+                        this.log2(`assigned '${leftSideReference.name}' to ClassComponent`);
+                    }
+                    else {
+                        itemType = globals_js_1.ReferenceTypes.variable;
+                        this.getScope().setVariable(leftSideReference.name, rhsValue);
+                        this.log2(`assigned variable ${leftSideReference.name} to ${rhsValue}`);
+                    }
+                    sequenceParts.push(...[itemType, leftSideReference.name, rhsValue]);
                 }
-                sequenceParts.push(...[itemType, leftSideReference.name, rhsValue]);
-            }
-            else {
-                if (leftSideReference.rootValue instanceof ClassComponent_js_1.ClassComponent) {
-                    this.setInstanceParam(leftSideReference.rootValue, trailers, rhsValue);
-                    this.log2(`assigned component param ${leftSideReference.rootValue} trailers: ${trailers} value: ${rhsValue}`);
-                    sequenceParts.push(...['instance', [leftSideReference.rootValue, trailers], rhsValue]);
-                    if (leftSideReference.rootValue.typeProp === globals_js_1.ComponentTypes.net) {
-                        const net = this.getScope().getNet(leftSideReference.rootValue, new PinDefinition_js_1.PinId(1));
-                        if (net) {
-                            const trailerValue = trailers.join(".");
-                            net.params.set(trailerValue, rhsValue);
+                else {
+                    if (leftSideReference.rootValue instanceof ClassComponent_js_1.ClassComponent) {
+                        this.setInstanceParam(leftSideReference.rootValue, trailers, rhsValue);
+                        this.log2(`assigned component param ${leftSideReference.rootValue} trailers: ${trailers} value: ${rhsValue}`);
+                        sequenceParts.push(...['instance', [leftSideReference.rootValue, trailers], rhsValue]);
+                        if (leftSideReference.rootValue.typeProp === globals_js_1.ComponentTypes.net) {
+                            const net = this.getScope().getNet(leftSideReference.rootValue, new PinDefinition_js_1.PinId(1));
+                            if (net) {
+                                const trailerValue = trailers.join(".");
+                                net.params.set(trailerValue, rhsValue);
+                            }
                         }
                     }
-                }
-                else if (leftSideReference.rootValue instanceof Object) {
-                    if (Array.isArray(trailers[0]) && trailers[0][0] === globals_js_1.TrailerArrayIndex) {
-                        if (Array.isArray(leftSideReference.rootValue)) {
-                            const arrayIndexValue = trailers[0][1];
-                            leftSideReference.rootValue[arrayIndexValue] = rhsValue;
-                            this.log2(`assigned array index ${leftSideReference.rootValue} index: ${arrayIndexValue} value: ${rhsValue}`);
+                    else if (leftSideReference.rootValue instanceof Object) {
+                        if (Array.isArray(trailers[0]) && trailers[0][0] === globals_js_1.TrailerArrayIndex) {
+                            if (Array.isArray(leftSideReference.rootValue)) {
+                                const arrayIndexValue = trailers[0][1];
+                                leftSideReference.rootValue[arrayIndexValue] = rhsValue;
+                                this.log2(`assigned array index ${leftSideReference.rootValue} index: ${arrayIndexValue} value: ${rhsValue}`);
+                            }
+                            else {
+                                this.throwWithContext(lhsCtx, "Invalid array");
+                            }
                         }
                         else {
-                            this.throwWithContext(lhsCtx, "Invalid array");
+                            let expandedValue = leftSideReference.rootValue;
+                            trailers.slice(0, -1).forEach(trailer => {
+                                expandedValue = expandedValue[trailer];
+                            });
+                            const lastTrailer = trailers.slice(-1)[0];
+                            expandedValue[lastTrailer] = rhsValue;
+                            this.log2(`assigned object ${leftSideReference.rootValue} trailers: ${trailers} value: ${rhsValue}`);
                         }
+                        sequenceParts.push(...['variable', [leftSideReference.rootValue, trailers], rhsValue]);
                     }
-                    else {
-                        let expandedValue = leftSideReference.rootValue;
-                        trailers.slice(0, -1).forEach(trailer => {
-                            expandedValue = expandedValue[trailer];
-                        });
-                        const lastTrailer = trailers.slice(-1)[0];
-                        expandedValue[lastTrailer] = rhsValue;
-                        this.log2(`assigned object ${leftSideReference.rootValue} trailers: ${trailers} value: ${rhsValue}`);
-                    }
-                    sequenceParts.push(...['variable', [leftSideReference.rootValue, trailers], rhsValue]);
                 }
-            }
-            if (sequenceParts.length > 0) {
-                this.getScope().sequence.push([
-                    ExecutionScope_js_1.SequenceAction.Assign, ...sequenceParts
-                ]);
-            }
-            this.setResult(ctx, rhsValue);
-        };
-        this.visitOperator_assignment_expr = (ctx) => {
-            const reference = this.getReference(ctx.atom_expr());
-            const value = this.visitResult(ctx.data_expr());
-            if (!reference.found) {
-                this.throwWithContext(ctx, 'Undefined reference: ' + reference.name);
-            }
-            const trailers = reference.trailers ?? [];
-            let currentValue = null;
-            if (trailers.length === 0) {
-                currentValue = this.getExecutor().scope.variables.get(reference.name);
+                if (sequenceParts.length > 0) {
+                    this.getScope().sequence.push([
+                        ExecutionScope_js_1.SequenceAction.Assign, ...sequenceParts
+                    ]);
+                }
+                this.setResult(ctx, rhsValue);
             }
             else {
-                if (reference.value instanceof ClassComponent_js_1.ClassComponent) {
-                    currentValue = this.getInstanceParam(reference.value, trailers);
+                const ctxCallable = ctx.callable_expr();
+                this.setResult(ctxCallable, { keepReference: true });
+                const reference = this.visitResult(ctx.callable_expr());
+                const value = this.visitResult(ctx.data_expr());
+                if (!reference.found) {
+                    this.throwWithContext(ctx, 'Undefined reference: ' + reference.name);
                 }
-                else if (reference.value instanceof Object) {
-                    currentValue = reference.value[trailers.join('.')];
+                const trailers = reference.trailers ?? [];
+                let currentValue = null;
+                if (trailers.length === 0) {
+                    currentValue = this.getExecutor().scope.variables.get(reference.name);
                 }
-            }
-            if (currentValue === null) {
-                this.throwWithContext(ctx, 'Operator assignment failed: could not get value');
-            }
-            let newValue = 0;
-            const operator = new ParamDefinition_js_1.NumberOperator();
-            if (ctx.AdditionAssign()) {
-                newValue = operator.addition(currentValue, value);
-            }
-            else if (ctx.MinusAssign()) {
-                newValue = operator.subtraction(currentValue, value);
-            }
-            else if (ctx.MultiplyAssign()) {
-                newValue = operator.multiply(currentValue, value);
-            }
-            else if (ctx.DivideAssign()) {
-                newValue = operator.divide(currentValue, value);
-            }
-            else if (ctx.ModulusAssign()) {
-                newValue = operator.modulus(currentValue, value);
-            }
-            else {
-                this.throwWithContext(ctx, 'Operator assignment failed: could not perform operator');
-            }
-            if (trailers.length === 0) {
-                this.getExecutor().scope.setVariable(reference.name, newValue);
-            }
-            else {
-                if (reference.value instanceof ClassComponent_js_1.ClassComponent) {
-                    this.setInstanceParam(reference.value, trailers, newValue);
+                else {
+                    if (reference.value instanceof ClassComponent_js_1.ClassComponent) {
+                        currentValue = this.getInstanceParam(reference.value, trailers);
+                    }
+                    else if (reference.value instanceof Object) {
+                        currentValue = reference.value[trailers.join('.')];
+                    }
+                }
+                if (currentValue === null) {
+                    this.throwWithContext(ctx, 'Operator assignment failed: could not get value');
                 }
-                else if (reference.value instanceof Object) {
-                    reference.value[trailers.join('.')] = newValue;
+                let newValue = 0;
+                const operator = new ParamDefinition_js_1.NumberOperator();
+                if (ctx.AdditionAssign()) {
+                    newValue = operator.addition(currentValue, value);
+                }
+                else if (ctx.MinusAssign()) {
+                    newValue = operator.subtraction(currentValue, value);
+                }
+                else if (ctx.MultiplyAssign()) {
+                    newValue = operator.multiply(currentValue, value);
+                }
+                else if (ctx.DivideAssign()) {
+                    newValue = operator.divide(currentValue, value);
+                }
+                else if (ctx.ModulusAssign()) {
+                    newValue = operator.modulus(currentValue, value);
+                }
+                else {
+                    this.throwWithContext(ctx, 'Operator assignment failed: could not perform operator');
                 }
+                if (trailers.length === 0) {
+                    this.getExecutor().scope.setVariable(reference.name, newValue);
+                }
+                else {
+                    if (reference.value instanceof ClassComponent_js_1.ClassComponent) {
+                        this.setInstanceParam(reference.value, trailers, newValue);
+                    }
+                    else if (reference.value instanceof Object) {
+                        reference.value[trailers.join('.')] = newValue;
+                    }
+                }
+                this.setResult(ctx, newValue);
             }
-            this.setResult(ctx, newValue);
         };
         this.visitTrailer_expr2 = (ctx) => {
             const reference = this.getResult(ctx);
@@ -235,7 +313,7 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
             const firstId = ctx.ID(0);
             const atomId = firstId.getText();
             let currentReference;
-            if (this.pinTypesList.indexOf(atomId) !== -1) {
+            if (globals_js_1.PinTypesList.indexOf(atomId) !== -1) {
                 currentReference = new types_js_1.AnyReference({
                     found: true,
                     value: atomId,
@@ -256,19 +334,6 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
             this.setResult(ctx, currentReference);
             this.log2('atom resolved: ' + ctx.getText() + ' -> ' + currentReference);
         };
-        this.visitFunctionCallExpr = (ctx) => {
-            const result = this.visitResult(ctx.function_call_expr());
-            this.setResult(ctx, result);
-        };
-        this.visitFunction_call_expr = (ctx) => {
-            const ctxParams = this.getResult(ctx);
-            const { keepReference = false } = ctxParams ?? {};
-            this.handleFunctionCall(ctx);
-            if (!keepReference) {
-                const functionResultReference = this.getResult(ctx);
-                this.setResult(ctx, functionResultReference.value);
-            }
-        };
         this.visitValue_expr = (ctx) => {
             const sign = ctx.Minus() ? -1 : 1;
             const ctxIntegerValue = ctx.INTEGER_VALUE();
@@ -312,30 +377,26 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
             }
             this.setResult(ctx, result);
         };
-        this.visitValueAtomExpr = (ctx) => {
+        this.visitValueExpr = (ctx) => {
+            this.passResult(ctx, ctx.value_expr());
+        };
+        this.visitAtomExpr = (ctx) => {
             let value = null;
-            const ctxValueExpr = ctx.value_expr();
-            const ctxAtomExpr = ctx.atom_expr();
-            if (ctxValueExpr) {
-                value = this.visitResult(ctxValueExpr);
+            const reference = this.visitResult(ctx.atom_expr());
+            if (!reference.found) {
+                value = new types_js_1.UndeclaredReference(reference);
             }
-            else if (ctxAtomExpr) {
-                const reference = this.visitResult(ctxAtomExpr);
-                if (!reference.found) {
-                    value = new types_js_1.UndeclaredReference(reference);
+            else {
+                if (reference.type && reference.type === globals_js_1.ReferenceTypes.pinType) {
+                    value = reference;
                 }
                 else {
-                    if (reference.type && reference.type === globals_js_1.ReferenceTypes.pinType) {
+                    if ((reference.trailers && reference.trailers.length > 0)
+                        || reference.type === globals_js_1.ReferenceTypes.function) {
                         value = reference;
                     }
                     else {
-                        if ((reference.trailers && reference.trailers.length > 0)
-                            || reference.type === globals_js_1.ReferenceTypes.function) {
-                            value = reference;
-                        }
-                        else {
-                            value = reference.value;
-                        }
+                        value = reference.value;
                     }
                 }
             }
@@ -359,6 +420,11 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
             });
             this.setResult(ctx, result);
         };
+        this.visitKeyword_assignment_expr = (ctx) => {
+            const id = ctx.ID().getText();
+            const value = this.visitResult(ctx.data_expr());
+            this.setResult(ctx, [id, value]);
+        };
         this.visitParameters = (ctx) => {
             const dataExpressions = ctx.data_expr();
             const keywordAssignmentExpressions = ctx.keyword_assignment_expr();
@@ -411,7 +477,10 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
             this.setResult(ctx, array);
         };
         this.visitArrayExpr = (ctx) => {
-            this.setResult(ctx, this.visitResult(ctx.array_expr()));
+            const array = ctx.data_expr().map(item => {
+                return this.visitResult(item);
+            });
+            this.setResult(ctx, array);
         };
         this.visitArrayIndexExpr = (ctx) => {
             const ctxArray = ctx.data_expr(0);
@@ -516,21 +585,38 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
     log2(message) {
         this.getExecutor().log(message);
     }
-    async visitAsync(ctx) {
-        const result = await ctx.accept(this);
-        return result;
+    async resolveImportsAndLoad(inputPath, scriptData) {
+        this.log('resolve and load imports');
+        const importedFiles = await (0, importResolver_js_1.resolveAllImportFilepaths)(inputPath, scriptData, this.environment);
+        this.log('resolved all referenced imports');
+        const loadedFiles = new Map();
+        for (const importFilePath of importedFiles) {
+            this.log(`reading file: ${importFilePath}`);
+            const importFileData = await this.environment.readFile(importFilePath);
+            loadedFiles.set(importFilePath, importFileData);
+        }
+        if (this.filePathStack.length > 0) {
+            const mainRefdesFile = this.getPathRefdesFile(this.filePathStack[0]);
+            const fileExists = await this.environment.exists(mainRefdesFile);
+            if (fileExists) {
+                this.log('.refdes.json file exists, reading it');
+                const mainRefdesFileData = await this.environment.readFile(mainRefdesFile);
+                loadedFiles.set(mainRefdesFile, mainRefdesFileData);
+            }
+        }
+        this.loadedFiles = loadedFiles;
     }
-    async importCommon(ctx, handling) {
+    importCommon(ctx, handling) {
         const specificImports = [];
-        if (ctx instanceof CircuitScriptParser_js_1.Import_specificContext) {
+        if (ctx instanceof CircuitScriptParser_js_1.Import_specific_or_allContext) {
             const tmpSpecificImports = ctx._funcNames.map(item => {
                 return item.text;
             });
             specificImports.push(...tmpSpecificImports);
         }
-        const id = ctx._libraryName.text;
-        const importedFile = await this.handleImportFile(id, handling, true, ctx, specificImports);
-        const ctxImportAnnotation = ctx.import_annotation_expr();
+        const id = ctx._libraryName.text.slice(1, -1);
+        const importedFile = this.handleImportFile(id, handling, true, ctx, specificImports);
+        const ctxImportAnnotation = ctx.annotation_comment_expr();
         if (ctxImportAnnotation) {
             const textValue = ctxImportAnnotation.getText().replace('#=', '');
             const { importedLibrary } = importedFile;
@@ -556,80 +642,52 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
         }
         return reference;
     }
-    handleFunctionCall(ctx) {
+    handleFunctionCall(currentReference, passedNetNamespace, ctx) {
         const executor = this.getExecutor();
-        const atomId = ctx.ID().getText();
-        let passedNetNamespace = null;
-        const netNameSpaceExpr = ctx.net_namespace_expr();
-        if (netNameSpaceExpr) {
-            passedNetNamespace = this.visitResult(netNameSpaceExpr);
+        let parameters = [];
+        const ctxParameters = ctx.parameters();
+        if (ctxParameters) {
+            parameters = this.visitResult(ctxParameters);
         }
-        let currentReference = executor.resolveVariable(this.executionStack, atomId);
-        if (ctx.trailer_expr().length > 0) {
-            if (!currentReference.found) {
-                this.log(`could not resolve function: ${atomId}`);
-                this.throwWithContext(ctx, "could not resolve function: " + atomId);
-            }
-            currentReference.trailers = [];
-            ctx.trailer_expr().forEach(item => {
-                if (item.OPEN_PAREN() && item.CLOSE_PAREN()) {
-                    if (currentReference.type === globals_js_1.ReferenceTypes.variable) {
-                        if (currentReference.value instanceof types_js_1.AnyReference && currentReference.value.type === globals_js_1.ReferenceTypes.function) {
-                            currentReference = currentReference.value;
-                        }
-                    }
-                    let parameters = [];
-                    const ctxParameters = item.parameters();
-                    if (ctxParameters) {
-                        parameters = this.visitResult(ctxParameters);
-                    }
-                    const useNetNamespace = this.getNetNamespace(executor.netNamespace, passedNetNamespace);
-                    try {
-                        const isLibraryFunction = currentReference.rootValue
-                            && currentReference.rootValue instanceof types_js_1.ImportedLibrary;
-                        if (isLibraryFunction) {
-                            this.log('create new library context');
-                            const importedLibrary = currentReference.rootValue;
-                            const { context: importedLibraryContext } = importedLibrary;
-                            this.enterFile(importedLibrary.libraryFilePath);
-                            const newExecutor = this.handleEnterContext(this.getExecutor(), this.executionStack, importedLibraryContext.name, ctx, {
-                                netNamespace: executor.netNamespace,
-                                namespace: importedLibrary.libraryNamespace
-                            }, [], [], false);
-                            this.log('copy library context scope');
-                            importedLibraryContext.scope.copyTo(newExecutor.scope);
-                        }
-                        const [, functionResult] = executor.callFunction(currentReference, parameters, this.executionStack, useNetNamespace);
-                        if (isLibraryFunction) {
-                            this.log('pop library context scope');
-                            this.handlePopContext(this.getExecutor(), this.executionStack, "", false);
-                            this.exitFile();
-                        }
-                        if ((0, utils_js_1.isReference)(functionResult)) {
-                            currentReference = functionResult;
-                        }
-                        else {
-                            currentReference = new types_js_1.AnyReference({
-                                found: true,
-                                value: functionResult,
-                                trailers: [],
-                                type: (functionResult instanceof ClassComponent_js_1.ClassComponent) ?
-                                    globals_js_1.ReferenceTypes.instance : globals_js_1.ReferenceTypes.value,
-                            });
-                        }
-                    }
-                    catch (err) {
-                        this.throwWithContext(ctx, err);
-                    }
-                }
-                else {
-                    const ctxTrailer = item.trailer_expr2();
-                    this.setResult(ctxTrailer, currentReference);
-                    currentReference = this.visitResult(ctxTrailer);
-                }
-            });
+        const useNetNamespace = this.getNetNamespace(executor.netNamespace, passedNetNamespace);
+        try {
+            const isLibraryFunction = currentReference.rootValue
+                && currentReference.rootValue instanceof types_js_1.ImportedLibrary;
+            if (isLibraryFunction) {
+                this.log('create new library context');
+                const importedLibrary = currentReference.rootValue;
+                const { context: importedLibraryContext } = importedLibrary;
+                this.enterFile(importedLibrary.libraryFilePath);
+                const newExecutor = this.handleEnterContext(this.getExecutor(), this.executionStack, importedLibraryContext.name, ctx, {
+                    netNamespace: executor.netNamespace,
+                    namespace: importedLibrary.libraryNamespace
+                }, [], [], false);
+                this.log('copy library context scope');
+                importedLibraryContext.scope.copyTo(newExecutor.scope);
+            }
+            const [, functionResult] = executor.callFunction(currentReference, parameters, this.executionStack, useNetNamespace);
+            if (isLibraryFunction) {
+                this.log('pop library context scope');
+                this.handlePopContext(this.getExecutor(), this.executionStack, "", false);
+                this.exitFile();
+            }
+            if ((0, utils_js_1.isReference)(functionResult)) {
+                currentReference = functionResult;
+            }
+            else {
+                currentReference = new types_js_1.AnyReference({
+                    found: true,
+                    value: functionResult,
+                    trailers: [],
+                    type: (functionResult instanceof ClassComponent_js_1.ClassComponent) ?
+                        globals_js_1.ReferenceTypes.instance : globals_js_1.ReferenceTypes.value,
+                });
+            }
         }
-        this.setResult(ctx, currentReference);
+        catch (err) {
+            this.throwWithContext(ctx, err);
+        }
+        return currentReference;
     }
     handleEnterContext(executor, executionStack, contextName, ctx, options, funcDefinedParameters, passedInParameters, isBreakContext = true) {
         if (isBreakContext) {
@@ -711,11 +769,27 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
         this.visit(ctx);
         return this.getResult(ctx);
     }
-    async handleImportFile(name, importHandling, throwErrors = true, ctx = null, specificImports = []) {
+    passResult(ctx, innerCtx) {
+        const params = this.getResult(ctx);
+        if (params) {
+            this.setResult(innerCtx, params);
+        }
+        this.setResult(ctx, this.visitResult(innerCtx));
+    }
+    handleImportFile(name, importHandling, throwErrors = true, ctx = null, specificImports = []) {
         name = name.trim();
         const importAlready = this.importedFiles.find(item => {
             return item.id === name;
         });
+        let importStatement;
+        if (ctx !== null) {
+            const start = ctx.start;
+            const inputStream = start.inputStream;
+            importStatement = [
+                start.line, start.column,
+                inputStream.getTextFromRange(start.start, ctx.stop.stop)
+            ];
+        }
         if (importAlready) {
             const { importedLibrary: tmpImportedLibrary } = importAlready;
             const alreadyImportedFlag = tmpImportedLibrary.importHandlingFlag;
@@ -744,14 +818,17 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
         let hasError = false;
         let hasParseError = false;
         let pathExists = false;
-        const tmpFilePath = this.environment.getRelativeToCurrentFolder(name + ".cst");
+        const tmpFilePath = this.environment.getAbsPathRelativeToCurrentFolder(name + ".cst");
+        const relativeFilePath = this.environment.relative(this.environment.getCurrentDirectory(), tmpFilePath);
         this.log('importing path:', tmpFilePath);
         let fileData = null;
         let filePathUsed = null;
         try {
-            filePathUsed = tmpFilePath;
-            fileData = await this.environment.readFile(tmpFilePath, { encoding: 'utf8' });
-            pathExists = true;
+            filePathUsed = relativeFilePath;
+            if (this.loadedFiles.has(relativeFilePath)) {
+                fileData = this.loadedFiles.get(relativeFilePath);
+                pathExists = true;
+            }
         }
         catch (err) {
             this.log('failed to read file');
@@ -763,8 +840,10 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
                 const tmpFilePath2 = this.environment.getRelativeToDefaultLibs(name + ".cst");
                 this.log('checking default libs: ' + tmpFilePath2);
                 filePathUsed = tmpFilePath2;
-                fileData = await this.environment.readFile(tmpFilePath2, { encoding: 'utf8' });
-                pathExists = true;
+                if (this.loadedFiles.has(tmpFilePath2)) {
+                    fileData = this.loadedFiles.get(tmpFilePath2);
+                    pathExists = true;
+                }
             }
             catch (err) {
                 this.log('failed to read file');
@@ -779,16 +858,46 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
                 const executionContextName = name;
                 const netNamespace = executor.netNamespace;
                 const libraryNamespace = `${globals_js_1.BaseNamespace}${name}.`;
-                this.enterNewChildContext(executionStack, executor, executionContextName, {
+                const importContext = this.enterNewChildContext(executionStack, executor, executionContextName, {
                     netNamespace,
                     namespace: libraryNamespace,
                 }, [], []);
-                const importResult = await this.onImportFile(this, filePathUsed, fileData, this.onErrorHandler);
-                hasError = importResult.hasError;
-                hasParseError = importResult.hasParseError;
-                const importContext = executionStack.pop();
-                this.log(`import handling flag: ${importHandling}`);
-                importedLibrary = new types_js_1.ImportedLibrary(name, libraryNamespace, filePathUsed, importResult.tree, importResult.tokens, importContext, importHandling, specificImports);
+                let loadedFromCache = false;
+                let contentHash = '';
+                if (this.enableCachedImportsRead) {
+                    try {
+                        contentHash = (0, hash_js_1.computeContentHash)(fileData);
+                        const cachedIR = (0, storage_js_1.readCache)(filePathUsed, contentHash);
+                        if (cachedIR !== null) {
+                            this.log('cache hit for:', filePathUsed);
+                            const parseAndVisit = (miniScript, lineOffset) => {
+                                return this.onImportFile(this, filePathUsed, miniScript, this.onErrorHandler, lineOffset);
+                            };
+                            importedLibrary = (0, deserializer_js_1.deserializeLibraryScope)(cachedIR, name, libraryNamespace, filePathUsed, importHandling, specificImports, importContext, parseAndVisit, () => {
+                                executionStack.push(importContext);
+                                return importContext;
+                            }, () => {
+                                executionStack.pop();
+                            }, contentHash);
+                            loadedFromCache = true;
+                            this.log('Done reading from import cache');
+                        }
+                    }
+                    catch (err) {
+                        this.log('Error while reading cache: ', err);
+                        loadedFromCache = false;
+                    }
+                }
+                if (!loadedFromCache) {
+                    const importResult = this.onImportFile(this, filePathUsed, fileData, this.onErrorHandler);
+                    hasError = importResult.hasError;
+                    hasParseError = importResult.hasParseError;
+                    this.log(`import handling flag: ${importHandling}`);
+                    importedLibrary = new types_js_1.ImportedLibrary(name, libraryNamespace, filePathUsed, importResult.tree, importResult.tokens, importContext, importHandling, specificImports, contentHash, importStatement);
+                    importedLibrary.parseError = hasError || hasParseError;
+                    importedLibrary.writeToCache = true;
+                }
+                executionStack.pop();
                 if (specificImports.length > 0) {
                     this.log('specific import: ' + specificImports.join(', '));
                 }
@@ -797,7 +906,8 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
                 importedLibrary.context.scope.libraries.forEach((lib, key) => {
                     scope.libraries.set(key, lib);
                 });
-                await this.checkLibraryHasRefdesFile(filePathUsed);
+                executor.mergeScope(importedLibrary.context.scope, importedLibrary.libraryNamespace);
+                this.checkLibraryInRefdesFile(filePathUsed);
             }
         }
         catch (err) {
@@ -830,10 +940,32 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
         this.importedFiles.push(newImportedFile);
         return newImportedFile;
     }
-    async checkLibraryHasRefdesFile(filePath) {
+    cacheLibraries() {
+        this.log('caching libraries');
+        const libraries = this.getScope().libraries;
+        for (const [libName, library] of libraries) {
+            this.log(`checking write flag for library ${library.libraryName}: ${library.writeToCache}`);
+            if (library.writeToCache && !library.parseError) {
+                try {
+                    const { fileHash } = library;
+                    const ir = (0, serializer_js_1.serializeLibraryScope)(library, fileHash);
+                    (0, storage_js_1.writeCache)(library.libraryFilePath, fileHash, ir);
+                    this.log(`created cache for library: ${libName}`);
+                }
+                catch (err) {
+                    this.log(`failed to cache library: ${libName}`);
+                    throw new utils_js_2.RuntimeExecutionError(`Failed to cache library: ${libName}`);
+                }
+            }
+        }
+    }
+    checkLibraryInRefdesFile(filePath) {
         return;
     }
-    getRefdesFileAnnotation(filePath, startLine, startColumn, stopLine, stopColumn) {
+    getPathRefdesFile(filePath) {
+        return '';
+    }
+    getRefdesFileAnnotationKey(filePath, startLine, startColumn, stopLine, stopColumn) {
         return `${filePath}:${startLine}:${startColumn}:${stopLine}:${stopColumn}`;
     }
     setupDefinedParameters(funcDefinedParameters, passedInParameters, executor) {