ts2famix 1.3.1 → 1.4.1

package/dist/analyze_functions/process_functions.js

@@ -0,0 +1,723 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processInvocations = exports.processInheritances = exports.processImportClausesForModules = exports.processImportClausesForImportEqualsDeclarations = exports.processAccesses = exports.processFiles = exports.getImplementedOrExtendedInterfaces = exports.getModulePath = exports.currentCC = exports.exportedMap = exports.modules = exports.interfaces = exports.classes = exports.accessMap = exports.methodsAndFunctionsWithId = void 0;
+const ts_morph_1 = require("ts-morph");
+const Famix = __importStar(require("../lib/famix/src/model/famix"));
+const cyclomatic_service_1 = require("../lib/ts-complex/cyclomatic-service");
+const fs = __importStar(require("fs"));
+const analyze_1 = require("../analyze");
+exports.methodsAndFunctionsWithId = new Map(); // Maps the Famix method, constructor, getter, setter and function ids to their ts-morph method, constructor, getter, setter or function object
+exports.accessMap = new Map(); // Maps the Famix parameter, variable, property and enum value ids to their ts-morph parameter, variable, property or enum member object
+exports.classes = new Array(); // Array of all the classes of the source files
+exports.interfaces = new Array(); // Array of all the interfaces of the source files
+exports.modules = new Array(); // Array of all the source files which are modules
+exports.exportedMap = new Array(); // Array of all the exports
+/**
+ * Checks if the file has any imports or exports to be considered a module
+ * @param sourceFile A source file
+ * @returns A boolean indicating if the file is a module
+ */
+function ismodule(sourceFile) {
+    return sourceFile.getImportDeclarations().length > 0 || sourceFile.getExportedDeclarations().size > 0;
+}
+/**
+ * Gets the path of a module to be imported
+ * @param i An import declaration
+ * @returns The path of the module to be imported
+ */
+function getModulePath(i) {
+    let path;
+    if (i.getModuleSpecifierSourceFile() === undefined) {
+        if (i.getModuleSpecifierValue().substring(i.getModuleSpecifierValue().length - 3) === ".ts") {
+            path = i.getModuleSpecifierValue();
+        }
+        else {
+            path = i.getModuleSpecifierValue() + ".ts";
+        }
+    }
+    else {
+        path = i.getModuleSpecifierSourceFile().getFilePath();
+    }
+    return path;
+}
+exports.getModulePath = getModulePath;
+/**
+ * Gets the interfaces implemented or extended by a class or an interface
+ * @param interfaces An array of interfaces
+ * @param subClass A class or an interface
+ * @returns An array of InterfaceDeclaration and ExpressionWithTypeArguments containing the interfaces implemented or extended by the subClass
+ */
+function getImplementedOrExtendedInterfaces(interfaces, subClass) {
+    let impOrExtInterfaces;
+    if (subClass instanceof ts_morph_1.ClassDeclaration) {
+        impOrExtInterfaces = subClass.getImplements();
+    }
+    else {
+        impOrExtInterfaces = subClass.getExtends();
+    }
+    const interfacesNames = interfaces.map(i => i.getName());
+    const implementedOrExtendedInterfaces = new Array();
+    impOrExtInterfaces.forEach(i => {
+        if (interfacesNames.includes(i.getExpression().getText())) {
+            implementedOrExtendedInterfaces.push(interfaces[interfacesNames.indexOf(i.getExpression().getText())]);
+        }
+        else {
+            implementedOrExtendedInterfaces.push(i);
+        }
+    });
+    return implementedOrExtendedInterfaces;
+}
+exports.getImplementedOrExtendedInterfaces = getImplementedOrExtendedInterfaces;
+/**
+ * Builds a Famix model for an array of source files
+ * @param sourceFiles An array of source files
+ */
+function processFiles(sourceFiles) {
+    sourceFiles.forEach(file => {
+        analyze_1.logger.info(`File: >>>>>>>>>> ${file.getFilePath()}`);
+        // Computes the cyclomatic complexity metrics for the current source file if it exists (i.e. if it is not from a jest test)
+        if (fs.existsSync(file.getFilePath()))
+            exports.currentCC = (0, cyclomatic_service_1.calculate)(file.getFilePath());
+        else
+            exports.currentCC = 0;
+        processFile(file);
+    });
+}
+exports.processFiles = processFiles;
+/**
+ * Builds a Famix model for a source file
+ * @param f A source file
+ */
+function processFile(f) {
+    const isModule = ismodule(f);
+    if (isModule) {
+        exports.modules.push(f);
+        exports.exportedMap.push(f.getExportedDeclarations());
+    }
+    const fmxFile = analyze_1.entityDictionary.createOrGetFamixFile(f, isModule);
+    analyze_1.logger.debug(`processFile: file: ${f.getBaseName()}, fqn = ${fmxFile.getFullyQualifiedName()}`);
+    processComments(f, fmxFile);
+    processAliases(f, fmxFile);
+    processClasses(f, fmxFile);
+    processInterfaces(f, fmxFile);
+    processVariables(f, fmxFile);
+    processEnums(f, fmxFile);
+    processFunctions(f, fmxFile);
+    processNamespaces(f, fmxFile);
+}
+/**
+ * Builds a Famix model for a namespace
+ * @param m A namespace
+ * @returns A Famix.Namespace representing the namespace
+ */
+function processNamespace(m) {
+    const fmxNamespace = analyze_1.entityDictionary.createOrGetFamixNamespace(m);
+    analyze_1.logger.debug(`processNamespace: namespace: ${m.getName()}, (${m.getType().getText()}), ${fmxNamespace.getFullyQualifiedName()}`);
+    processComments(m, fmxNamespace);
+    processAliases(m, fmxNamespace);
+    processClasses(m, fmxNamespace);
+    processInterfaces(m, fmxNamespace);
+    processVariables(m, fmxNamespace);
+    processEnums(m, fmxNamespace);
+    processFunctions(m, fmxNamespace);
+    processNamespaces(m, fmxNamespace);
+    return fmxNamespace;
+}
+/**
+ * Builds a Famix model for the aliases of a container
+ * @param m A container (a source file, a namespace, a function or a method)
+ * @param fmxScope The Famix model of the container
+ */
+function processAliases(m, fmxScope) {
+    analyze_1.logger.debug(`processAliases: ---------- Finding Aliases:`);
+    m.getTypeAliases().forEach(a => {
+        const fmxAlias = processAlias(a);
+        fmxScope.addAlias(fmxAlias);
+    });
+}
+/**
+ * Builds a Famix model for the classes of a container
+ * @param m A container (a source file or a namespace)
+ * @param fmxScope The Famix model of the container
+ */
+function processClasses(m, fmxScope) {
+    analyze_1.logger.debug(`processClasses: ---------- Finding Classes:`);
+    m.getClasses().forEach(c => {
+        const fmxClass = processClass(c);
+        fmxScope.addType(fmxClass);
+    });
+}
+/**
+ * Builds a Famix model for the interfaces of a container
+ * @param m A container (a source file or a namespace)
+ * @param fmxScope The Famix model of the container
+ */
+function processInterfaces(m, fmxScope) {
+    analyze_1.logger.debug(`processInterfaces: ---------- Finding Interfaces:`);
+    m.getInterfaces().forEach(i => {
+        const fmxInterface = processInterface(i);
+        fmxScope.addType(fmxInterface);
+    });
+}
+/**
+ * Builds a Famix model for the variables of a container
+ * @param m A container (a source file, a namespace, a function or a method)
+ * @param fmxScope The Famix model of the container
+ */
+function processVariables(m, fmxScope) {
+    analyze_1.logger.debug(`processVariables: ---------- Finding Variables:`);
+    m.getVariableStatements().forEach(v => {
+        const fmxVariables = processVariableStatement(v);
+        fmxVariables.forEach(fmxVariable => {
+            fmxScope.addVariable(fmxVariable);
+        });
+    });
+}
+/**
+ * Builds a Famix model for the enums of a container
+ * @param m A container (a source file, a namespace, a function or a method)
+ * @param fmxScope The Famix model of the container
+ */
+function processEnums(m, fmxScope) {
+    analyze_1.logger.debug(`processEnums: ---------- Finding Enums:`);
+    m.getEnums().forEach(e => {
+        const fmxEnum = processEnum(e);
+        fmxScope.addType(fmxEnum);
+    });
+}
+/**
+ * Builds a Famix model for the functions of a container
+ * @param m A container (a source file, a namespace, a function or a method)
+ * @param fmxScope The Famix model of the container
+ */
+function processFunctions(m, fmxScope) {
+    analyze_1.logger.debug(`Finding Functions:`);
+    m.getFunctions().forEach(f => {
+        const fmxFunction = processFunction(f);
+        fmxScope.addFunction(fmxFunction);
+    });
+}
+/**
+ * Builds a Famix model for the namespaces of a container
+ * @param m A container (a source file or a namespace)
+ * @param fmxScope The Famix model of the container
+ */
+function processNamespaces(m, fmxScope) {
+    analyze_1.logger.debug(`Finding Namespaces:`);
+    m.getModules().forEach(md => {
+        const fmxNsp = processNamespace(md);
+        fmxScope.addNamespace(fmxNsp);
+    });
+}
+/**
+ * Builds a Famix model for an alias
+ * @param a An alias
+ * @returns A Famix.Alias representing the alias
+ */
+function processAlias(a) {
+    const fmxAlias = analyze_1.entityDictionary.createFamixAlias(a);
+    analyze_1.logger.debug(`Alias: ${a.getName()}, (${a.getType().getText()}), fqn = ${fmxAlias.getFullyQualifiedName()}`);
+    processComments(a, fmxAlias);
+    return fmxAlias;
+}
+/**
+ * Builds a Famix model for a class
+ * @param c A class
+ * @returns A Famix.Class or a Famix.ParameterizableClass representing the class
+ */
+function processClass(c) {
+    exports.classes.push(c);
+    const fmxClass = analyze_1.entityDictionary.createOrGetFamixClass(c);
+    analyze_1.logger.debug(`Class: ${c.getName()}, (${c.getType().getText()}), fqn = ${fmxClass.getFullyQualifiedName()}`);
+    processComments(c, fmxClass);
+    processDecorators(c, fmxClass);
+    processStructuredType(c, fmxClass);
+    c.getConstructors().forEach(con => {
+        const fmxCon = processMethod(con);
+        fmxClass.addMethod(fmxCon);
+    });
+    c.getGetAccessors().forEach(acc => {
+        const fmxAcc = processMethod(acc);
+        fmxClass.addMethod(fmxAcc);
+    });
+    c.getSetAccessors().forEach(acc => {
+        const fmxAcc = processMethod(acc);
+        fmxClass.addMethod(fmxAcc);
+    });
+    return fmxClass;
+}
+/**
+ * Builds a Famix model for an interface
+ * @param i An interface
+ * @returns A Famix.Interface or a Famix.ParameterizableInterface representing the interface
+ */
+function processInterface(i) {
+    exports.interfaces.push(i);
+    const fmxInterface = analyze_1.entityDictionary.createOrGetFamixInterface(i);
+    analyze_1.logger.debug(`Interface: ${i.getName()}, (${i.getType().getText()}), fqn = ${fmxInterface.getFullyQualifiedName()}`);
+    processComments(i, fmxInterface);
+    processStructuredType(i, fmxInterface);
+    return fmxInterface;
+}
+/**
+ * Builds a Famix model for the type parameters, properties and methods of a structured type
+ * @param c A structured type (a class or an interface)
+ * @param fmxScope The Famix model of the structured type
+ */
+function processStructuredType(c, fmxScope) {
+    analyze_1.logger.debug(`Finding Properties and Methods:`);
+    if (fmxScope instanceof Famix.ParameterizableClass || fmxScope instanceof Famix.ParameterizableInterface) {
+        processTypeParameters(c, fmxScope);
+    }
+    c.getProperties().forEach(prop => {
+        const fmxProperty = processProperty(prop);
+        fmxScope.addProperty(fmxProperty);
+    });
+    c.getMethods().forEach(m => {
+        const fmxMethod = processMethod(m);
+        fmxScope.addMethod(fmxMethod);
+    });
+}
+/**
+ * Builds a Famix model for a property
+ * @param p A property
+ * @returns A Famix.Property representing the property
+ */
+function processProperty(p) {
+    const fmxProperty = analyze_1.entityDictionary.createFamixProperty(p);
+    analyze_1.logger.debug(`property: ${p.getName()}, (${p.getType().getText()}), fqn = ${fmxProperty.getFullyQualifiedName()}`);
+    analyze_1.logger.debug(` ---> It's a Property${(p instanceof ts_morph_1.PropertySignature) ? "Signature" : "Declaration"}!`);
+    const ancestor = p.getFirstAncestorOrThrow();
+    analyze_1.logger.debug(` ---> Its first ancestor is a ${ancestor.getKindName()}`);
+    if (!(p instanceof ts_morph_1.PropertySignature)) {
+        processDecorators(p, fmxProperty);
+        // only add access if the p's first ancestor is not a PropertyDeclaration
+        if (ancestor.getKindName() !== "PropertyDeclaration") {
+            analyze_1.logger.debug(`adding access: ${p.getName()}, (${p.getType().getText()}) Famix ${fmxProperty.getName()}`);
+            exports.accessMap.set(fmxProperty.id, p);
+        }
+    }
+    processComments(p, fmxProperty);
+    return fmxProperty;
+}
+/**
+     * Builds a Famix model for a method or an accessor
+     * @param m A method or an accessor
+     * @returns A Famix.Method or a Famix.Accessor representing the method or the accessor
+     */
+function processMethod(m) {
+    const fmxMethod = analyze_1.entityDictionary.createFamixMethod(m, exports.currentCC);
+    analyze_1.logger.debug(`Method: ${!(m instanceof ts_morph_1.ConstructorDeclaration) ? m.getName() : "constructor"}, (${m.getType().getText()}), parent: ${m.getParent().getName()}, fqn = ${fmxMethod.getFullyQualifiedName()}`);
+    processComments(m, fmxMethod);
+    processTypeParameters(m, fmxMethod);
+    processParameters(m, fmxMethod);
+    if (!(m instanceof ts_morph_1.MethodSignature)) {
+        processAliases(m, fmxMethod);
+        processVariables(m, fmxMethod);
+        processEnums(m, fmxMethod);
+        processFunctions(m, fmxMethod);
+        processFunctionExpressions(m, fmxMethod);
+        exports.methodsAndFunctionsWithId.set(fmxMethod.id, m);
+    }
+    if (m instanceof ts_morph_1.MethodDeclaration || m instanceof ts_morph_1.GetAccessorDeclaration || m instanceof ts_morph_1.SetAccessorDeclaration) {
+        processDecorators(m, fmxMethod);
+    }
+    return fmxMethod;
+}
+/**
+ * Builds a Famix model for a function
+ * @param f A function
+ * @returns A Famix.Function representing the function
+ */
+function processFunction(f) {
+    const fmxFunction = analyze_1.entityDictionary.createFamixFunction(f, exports.currentCC);
+    analyze_1.logger.debug(`Function: ${(f.getName()) ? f.getName() : "anonymous"}, (${f.getType().getText()}), fqn = ${fmxFunction.getFullyQualifiedName()}`);
+    processComments(f, fmxFunction);
+    processAliases(f, fmxFunction);
+    processTypeParameters(f, fmxFunction);
+    processParameters(f, fmxFunction);
+    processVariables(f, fmxFunction);
+    processEnums(f, fmxFunction);
+    processFunctions(f, fmxFunction);
+    if (f instanceof ts_morph_1.FunctionDeclaration && !(f.getParent() instanceof ts_morph_1.Block)) {
+        processFunctionExpressions(f, fmxFunction);
+    }
+    exports.methodsAndFunctionsWithId.set(fmxFunction.id, f);
+    return fmxFunction;
+}
+/**
+ * Builds a Famix model for the function expressions of a function or a method
+ * @param f A function or a method
+ * @param fmxScope The Famix model of the function or the method
+ */
+function processFunctionExpressions(f, fmxScope) {
+    analyze_1.logger.debug(`Finding Function Expressions:`);
+    const functionExpressions = f.getDescendantsOfKind(ts_morph_1.SyntaxKind.FunctionExpression);
+    functionExpressions.forEach((func) => {
+        const fmxFunc = processFunction(func);
+        fmxScope.addFunction(fmxFunc);
+    });
+}
+/**
+ * Builds a Famix model for the parameters of a method or a function
+ * @param m A method or a function
+ * @param fmxScope The Famix model of the method or the function
+ */
+function processParameters(m, fmxScope) {
+    analyze_1.logger.debug(`Finding Parameters:`);
+    m.getParameters().forEach(param => {
+        const fmxParam = processParameter(param);
+        fmxScope.addParameter(fmxParam);
+    });
+}
+/**
+ * Builds a Famix model for a parameter
+ * @param p A parameter
+ * @returns A Famix.Parameter representing the parameter
+ */
+function processParameter(p) {
+    const fmxParam = analyze_1.entityDictionary.createFamixParameter(p);
+    analyze_1.logger.debug(`parameter: ${p.getName()}, (${p.getType().getText()}), fqn = ${fmxParam.getFullyQualifiedName()}`);
+    processComments(p, fmxParam);
+    processDecorators(p, fmxParam);
+    const parent = p.getParent();
+    if (!(parent instanceof ts_morph_1.MethodSignature)) {
+        analyze_1.logger.debug(`adding access: ${p.getName()}, (${p.getType().getText()}) Famix ${fmxParam.getName()}`);
+        exports.accessMap.set(fmxParam.id, p);
+    }
+    return fmxParam;
+}
+/**
+ * Builds a Famix model for the type parameters of a class, an interface, a method or a function
+ * @param e A class, an interface, a method or a function
+ * @param fmxScope The Famix model of the class, the interface, the method or the function
+ */
+function processTypeParameters(e, fmxScope) {
+    analyze_1.logger.debug(`Finding Type Parameters:`);
+    e.getTypeParameters().forEach(tp => {
+        const fmxParam = processTypeParameter(tp);
+        fmxScope.addParameterType(fmxParam);
+    });
+}
+/**
+ * Builds a Famix model for a type parameter
+ * @param tp A type parameter
+ * @returns A Famix.TypeParameter representing the type parameter
+ */
+function processTypeParameter(tp) {
+    const fmxTypeParameter = analyze_1.entityDictionary.createFamixParameterType(tp);
+    analyze_1.logger.debug(`type parameter: ${tp.getName()}, (${tp.getType().getText()}), fqn = ${fmxTypeParameter.getFullyQualifiedName()}`);
+    processComments(tp, fmxTypeParameter);
+    return fmxTypeParameter;
+}
+/**
+ * Builds a Famix model for the variables of a variable statement
+ * @param v A variable statement
+ * @returns An array of Famix.Variable representing the variables
+ */
+function processVariableStatement(v) {
+    const fmxVariables = new Array();
+    analyze_1.logger.debug(`Variable statement: ${v.getText()}, (${v.getType().getText()}), ${v.getDeclarationKindKeywords()[0]}, fqn = ${v.getDeclarations()[0].getName()}`);
+    v.getDeclarations().forEach(variable => {
+        const fmxVar = processVariable(variable);
+        processComments(v, fmxVar);
+        fmxVariables.push(fmxVar);
+    });
+    return fmxVariables;
+}
+/**
+ * Builds a Famix model for a variable
+ * @param v A variable
+ * @returns A Famix.Variable representing the variable
+ */
+function processVariable(v) {
+    const fmxVar = analyze_1.entityDictionary.createFamixVariable(v);
+    analyze_1.logger.debug(`variable: ${v.getName()}, (${v.getType().getText()}), ${v.getInitializer() ? "initializer: " + v.getInitializer().getText() : "initializer: "}, fqn = ${fmxVar.getFullyQualifiedName()}`);
+    processComments(v, fmxVar);
+    analyze_1.logger.debug(`adding access: ${v.getName()}, (${v.getType().getText()}) Famix ${fmxVar.getName()}`);
+    exports.accessMap.set(fmxVar.id, v);
+    return fmxVar;
+}
+/**
+ * Builds a Famix model for an enum
+ * @param e An enum
+ * @returns A Famix.Enum representing the enum
+ */
+function processEnum(e) {
+    const fmxEnum = analyze_1.entityDictionary.createFamixEnum(e);
+    analyze_1.logger.debug(`enum: ${e.getName()}, (${e.getType().getText()}), fqn = ${fmxEnum.getFullyQualifiedName()}`);
+    processComments(e, fmxEnum);
+    e.getMembers().forEach(m => {
+        const fmxEnumValue = processEnumValue(m);
+        fmxEnum.addValue(fmxEnumValue);
+    });
+    return fmxEnum;
+}
+/**
+ * Builds a Famix model for an enum member
+ * @param v An enum member
+ * @returns A Famix.EnumValue representing the enum member
+ */
+function processEnumValue(v) {
+    const fmxEnumValue = analyze_1.entityDictionary.createFamixEnumValue(v);
+    analyze_1.logger.debug(`enum value: ${v.getName()}, (${v.getType().getText()}), fqn = ${fmxEnumValue.getFullyQualifiedName()}`);
+    processComments(v, fmxEnumValue);
+    analyze_1.logger.debug(`adding access: ${v.getName()}, (${v.getType().getText()}) Famix ${fmxEnumValue.getName()}`);
+    exports.accessMap.set(fmxEnumValue.id, v);
+    return fmxEnumValue;
+}
+/**
+ * Builds a Famix model for the decorators of a class, a method, a parameter or a property
+ * @param e A class, a method, a parameter or a property
+ * @param fmxScope The Famix model of the class, the method, the parameter or the property
+ */
+function processDecorators(e, fmxScope) {
+    analyze_1.logger.debug(`Finding Decorators:`);
+    e.getDecorators().forEach(dec => {
+        const fmxDec = processDecorator(dec, e);
+        fmxScope.addDecorator(fmxDec);
+    });
+}
+/**
+ * Builds a Famix model for a decorator
+ * @param d A decorator
+ * @param e A class, a method, a parameter or a property
+ * @returns A Famix.Decorator representing the decorator
+ */
+function processDecorator(d, e) {
+    const fmxDec = analyze_1.entityDictionary.createOrGetFamixDecorator(d, e);
+    analyze_1.logger.debug(`decorator: ${d.getName()}, (${d.getType().getText()}), fqn = ${fmxDec.getFullyQualifiedName()}`);
+    processComments(d, fmxDec);
+    return fmxDec;
+}
+/**
+ * Builds a Famix model for the comments
+ * @param e A ts-morph element
+ * @param fmxScope The Famix model of the named entity
+ */
+function processComments(e, fmxScope) {
+    analyze_1.logger.debug(`Process comments:`);
+    e.getLeadingCommentRanges().forEach(c => {
+        const fmxComment = processComment(c, fmxScope);
+        analyze_1.logger.debug(`leading comments, addComment: '${c.getText()}'`);
+        fmxScope.addComment(fmxComment); // redundant, but just in case
+    });
+    e.getTrailingCommentRanges().forEach(c => {
+        const fmxComment = processComment(c, fmxScope);
+        analyze_1.logger.debug(`trailing comments, addComment: '${c.getText()}'`);
+        fmxScope.addComment(fmxComment);
+    });
+}
+/**
+ * Builds a Famix model for a comment
+ * @param c A comment
+ * @param fmxScope The Famix model of the comment's container
+ * @returns A Famix.Comment representing the comment
+ */
+function processComment(c, fmxScope) {
+    const isJSDoc = c.getText().startsWith("/**");
+    analyze_1.logger.debug(`processComment: comment: ${c.getText()}, isJSDoc = ${isJSDoc}`);
+    const fmxComment = analyze_1.entityDictionary.createFamixComment(c, fmxScope, isJSDoc);
+    return fmxComment;
+}
+/**
+ * Builds a Famix model for the accesses on the parameters, variables, properties and enum members of the source files
+ * @param accessMap A map of parameters, variables, properties and enum members with their id
+ */
+function processAccesses(accessMap) {
+    analyze_1.logger.debug(`processAccesses: Creating accesses:`);
+    accessMap.forEach((v, id) => {
+        analyze_1.logger.debug(`processAccesses: Accesses to ${v.getName()}`);
+        try {
+            const temp_nodes = v.findReferencesAsNodes();
+            temp_nodes.forEach(node => processNodeForAccesses(node, id));
+        }
+        catch (error) {
+            analyze_1.logger.error(`> WARNING: got exception ${error}. Continuing...`);
+        }
+    });
+}
+exports.processAccesses = processAccesses;
+/**
+ * Builds a Famix model for an access on a parameter, variable, property or enum member
+ * @param n A node
+ * @param id An id of a parameter, a variable, a property or an enum member
+ */
+function processNodeForAccesses(n, id) {
+    try {
+        // sometimes node's first ancestor is a PropertyDeclaration, which is not an access
+        // see https://github.com/fuhrmanator/FamixTypeScriptImporter/issues/9
+        // check for a node whose first ancestor is a property declaration and bail?
+        // This may be a bug in ts-morph?
+        if (n.getFirstAncestorOrThrow().getKindName() === "PropertyDeclaration") {
+            analyze_1.logger.debug(`processNodeForAccesses: node kind: ${n.getKindName()}, ${n.getText()}, (${n.getType().getText()})'s first ancestor is a PropertyDeclaration. Skipping...`);
+            return;
+        }
+        analyze_1.entityDictionary.createFamixAccess(n, id);
+        analyze_1.logger.debug(`processNodeForAccesses: node kind: ${n.getKindName()}, ${n.getText()}, (${n.getType().getText()})`);
+    }
+    catch (error) {
+        analyze_1.logger.error(`> WARNING: got exception ${error}. ScopeDeclaration invalid for ${n.getSymbol().getFullyQualifiedName()}. Continuing...`);
+    }
+}
+function processImportClausesForImportEqualsDeclarations(sourceFiles, exports) {
+    analyze_1.logger.info(`Creating import clauses from ImportEqualsDeclarations in source files:`);
+    sourceFiles.forEach(sourceFile => {
+        sourceFile.forEachDescendant(node => {
+            if (ts_morph_1.Node.isImportEqualsDeclaration(node)) {
+                // You've found an ImportEqualsDeclaration
+                analyze_1.logger.info("Declaration Name:", node.getName());
+                analyze_1.logger.info("Module Reference Text:", node.getModuleReference().getText());
+                // create a famix import clause
+                const namedImport = node.getNameNode();
+                analyze_1.entityDictionary.createFamixImportClause({ importDeclaration: node,
+                    importer: sourceFile,
+                    moduleSpecifierFilePath: node.getModuleReference().getText(),
+                    importElement: namedImport,
+                    isInExports: exports.find(e => e.has(namedImport.getText())) !== undefined,
+                    isDefaultExport: false });
+            }
+        });
+    });
+}
+exports.processImportClausesForImportEqualsDeclarations = processImportClausesForImportEqualsDeclarations;
+/**
+     * Builds a Famix model for the import clauses of the source files which are modules
+     * @param modules An array of modules
+     * @param exports An array of maps of exported declarations
+     */
+function processImportClausesForModules(modules, exports) {
+    analyze_1.logger.info(`Creating import clauses from ${modules.length} modules:`);
+    modules.forEach(module => {
+        module.getImportDeclarations().forEach(impDecl => {
+            analyze_1.logger.debug(`Importing ${impDecl.getModuleSpecifierValue()}`);
+            const path = getModulePath(impDecl);
+            impDecl.getNamedImports().forEach(namedImport => {
+                analyze_1.logger.debug(`Importing (named) ${namedImport.getName()} from ${impDecl.getModuleSpecifierValue()}`);
+                const importedEntityName = namedImport.getName();
+                let importFoundInExports = false;
+                exports.forEach(e => {
+                    if (e.has(importedEntityName)) {
+                        importFoundInExports = true;
+                    }
+                });
+                analyze_1.entityDictionary.createFamixImportClause({ importDeclaration: impDecl,
+                    importer: module,
+                    moduleSpecifierFilePath: path,
+                    importElement: namedImport,
+                    isInExports: importFoundInExports,
+                    isDefaultExport: false });
+            });
+            const defaultImport = impDecl.getDefaultImport();
+            if (defaultImport !== undefined) {
+                analyze_1.logger.debug(`Importing (default) ${defaultImport.getText()} from ${impDecl.getModuleSpecifierValue()}`);
+                // call with module, impDecl.getModuleSpecifierValue(), path, defaultImport, false, true
+                analyze_1.entityDictionary.createFamixImportClause({ importDeclaration: impDecl,
+                    importer: module,
+                    moduleSpecifierFilePath: path,
+                    importElement: defaultImport,
+                    isInExports: false,
+                    isDefaultExport: true });
+            }
+            const namespaceImport = impDecl.getNamespaceImport();
+            if (namespaceImport !== undefined) {
+                analyze_1.logger.debug(`Importing (namespace) ${namespaceImport.getText()} from ${impDecl.getModuleSpecifierValue()}`);
+                analyze_1.entityDictionary.createFamixImportClause({ importDeclaration: impDecl,
+                    importer: module,
+                    moduleSpecifierFilePath: path,
+                    importElement: namespaceImport,
+                    isInExports: false,
+                    isDefaultExport: false });
+                // entityDictionary.createFamixImportClause(module, impDecl.getModuleSpecifierValue(), path, namespaceImport, false, false);
+            }
+        });
+    });
+}
+exports.processImportClausesForModules = processImportClausesForModules;
+/**
+     * Builds a Famix model for the inheritances of the classes and interfaces of the source files
+     * @param classes An array of classes
+     * @param interfaces An array of interfaces
+     */
+function processInheritances(classes, interfaces) {
+    analyze_1.logger.info(`processInheritances: Creating inheritances:`);
+    classes.forEach(cls => {
+        analyze_1.logger.debug(`processInheritances: Checking class inheritance for ${cls.getName()}`);
+        const extClass = cls.getBaseClass();
+        if (extClass !== undefined) {
+            analyze_1.entityDictionary.createFamixInheritance(cls, extClass);
+            analyze_1.logger.debug(`processInheritances: class: ${cls.getName()}, (${cls.getType().getText()}), extClass: ${extClass.getName()}, (${extClass.getType().getText()})`);
+        }
+        analyze_1.logger.debug(`processInheritances: Checking interface inheritance for ${cls.getName()}`);
+        const implementedInterfaces = getImplementedOrExtendedInterfaces(interfaces, cls);
+        implementedInterfaces.forEach(impInter => {
+            analyze_1.entityDictionary.createFamixInheritance(cls, impInter);
+            analyze_1.logger.debug(`processInheritances: class: ${cls.getName()}, (${cls.getType().getText()}), impInter: ${(impInter instanceof ts_morph_1.InterfaceDeclaration) ? impInter.getName() : impInter.getExpression().getText()}, (${(impInter instanceof ts_morph_1.InterfaceDeclaration) ? impInter.getType().getText() : impInter.getExpression().getText()})`);
+        });
+    });
+    interfaces.forEach(inter => {
+        analyze_1.logger.debug(`processInheritances: Checking interface inheritance for ${inter.getName()}`);
+        const extendedInterfaces = getImplementedOrExtendedInterfaces(interfaces, inter);
+        extendedInterfaces.forEach(extInter => {
+            analyze_1.entityDictionary.createFamixInheritance(inter, extInter);
+            analyze_1.logger.debug(`processInheritances: inter: ${inter.getName()}, (${inter.getType().getText()}), extInter: ${(extInter instanceof ts_morph_1.InterfaceDeclaration) ? extInter.getName() : extInter.getExpression().getText()}, (${(extInter instanceof ts_morph_1.InterfaceDeclaration) ? extInter.getType().getText() : extInter.getExpression().getText()})`);
+        });
+    });
+}
+exports.processInheritances = processInheritances;
+/**
+ * Builds a Famix model for the invocations of the methods and functions of the source files
+ * @param methodsAndFunctionsWithId A map of methods and functions with their id
+ */
+function processInvocations(methodsAndFunctionsWithId) {
+    analyze_1.logger.info(`Creating invocations:`);
+    methodsAndFunctionsWithId.forEach((m, id) => {
+        analyze_1.logger.debug(`Invocations to ${(m instanceof ts_morph_1.MethodDeclaration || m instanceof ts_morph_1.GetAccessorDeclaration || m instanceof ts_morph_1.SetAccessorDeclaration || m instanceof ts_morph_1.FunctionDeclaration) ? m.getName() : ((m instanceof ts_morph_1.ConstructorDeclaration) ? 'constructor' : (m.getName() ? m.getName() : 'anonymous'))}`);
+        try {
+            const temp_nodes = m.findReferencesAsNodes();
+            temp_nodes.forEach(node => processNodeForInvocations(node, m, id));
+        }
+        catch (error) {
+            analyze_1.logger.error(`> WARNING: got exception ${error}. Continuing...`);
+        }
+    });
+}
+exports.processInvocations = processInvocations;
+/**
+ * Builds a Famix model for an invocation of a method or a function
+ * @param n A node
+ * @param m A method or a function
+ * @param id The id of the method or the function
+ */
+function processNodeForInvocations(n, m, id) {
+    try {
+        analyze_1.entityDictionary.createFamixInvocation(n, m, id);
+        analyze_1.logger.debug(`node: node, (${n.getType().getText()})`);
+    }
+    catch (error) {
+        analyze_1.logger.error(`> WARNING: got exception ${error}. ScopeDeclaration invalid for ${n.getSymbol().getFullyQualifiedName()}. Continuing...`);
+    }
+}