ts2famix 1.0.1 → 1.0.4

package/dist/analyze.js

@@ -0,0 +1,102 @@
+"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.Importer = void 0;
+const ts_morph_1 = require("ts-morph");
+const fs = __importStar(require("fs"));
+const famix_functions_1 = require("./famix_functions/famix_functions");
+const processFiles_1 = require("./analyze_functions/processFiles");
+const processAccesses_1 = require("./analyze_functions/processAccesses");
+const processInvocations_1 = require("./analyze_functions/processInvocations");
+const processInheritances_1 = require("./analyze_functions/processInheritances");
+const processImportClauses_1 = require("./analyze_functions/processImportClauses");
+/**
+ * This class is used to build a Famix model from a TypeScript source code
+ */
+class Importer {
+    constructor() {
+        this.project = new ts_morph_1.Project(); // The project containing the source files to analyze
+        this.famixFunctions = new famix_functions_1.FamixFunctions(); // FamixFunctions object, it contains all the functions needed to create Famix entities
+        this.processFiles = new processFiles_1.ProcessFiles(this.famixFunctions); // ProcessFiles object, it contains all the functions needed to process the source files
+        this.processAccesses = new processAccesses_1.ProcessAccesses(this.famixFunctions); // ProcessAccesses object, it contains all the functions needed to process the accesses
+        this.processInvocations = new processInvocations_1.ProcessInvocations(this.famixFunctions); // ProcessInvocations object, it contains all the functions needed to process the invocations
+        this.processInheritances = new processInheritances_1.ProcessInheritances(this.famixFunctions); // ProcessInheritances object, it contains all the functions needed to process the inheritances
+        this.processImportClauses = new processImportClauses_1.ProcessImportClauses(this.famixFunctions); // ProcessImportClauses object, it contains all the functions needed to process the import clauses
+    }
+    /**
+     * Main method
+     * @param paths An array of paths to the source files to analyze
+     * @returns The Famix repository containing the Famix model
+     */
+    famixRepFromPaths(paths) {
+        let famixRep;
+        try {
+            console.info(`famixRepFromPaths: paths: ${paths}`);
+            const sourceFiles = this.project.addSourceFilesAtPaths(paths);
+            this.processFiles.processFiles(sourceFiles);
+            const accesses = this.processFiles.getAccesses();
+            const methodsAndFunctionsWithId = this.processFiles.getMethodsAndFunctionsWithId();
+            const classes = this.processFiles.getClasses();
+            const interfaces = this.processFiles.getInterfaces();
+            const modules = this.processFiles.getModules();
+            const exports = this.processFiles.getExports();
+            this.processImportClauses.processImportClauses(modules, exports);
+            this.processAccesses.processAccesses(accesses);
+            this.processInvocations.processInvocations(methodsAndFunctionsWithId);
+            this.processInheritances.processInheritances(classes, interfaces);
+            famixRep = this.famixFunctions.getFamixRepository();
+        }
+        catch (error) {
+            console.error(`> ERROR: got exception ${error}. Exiting...`);
+            console.error(error.message);
+            console.error(error.stack);
+            process.exit(1);
+        }
+        return famixRep;
+    }
+    /**
+     * Main method for tests
+     * @param filename The name of the file to analyze
+     * @param source A TypeScript source code
+     * @returns The Famix repository containing the Famix model
+     */
+    famixRepFromSource(filename, source) {
+        const filePath = `./test_src/${filename}.ts`;
+        fs.writeFileSync(filePath, source, 'utf-8');
+        const famixRep = this.famixRepFromPaths([filePath]);
+        return famixRep;
+    }
+    /**
+     * Main method for a ts-morph project
+     * @param project A ts-morph project
+     * @returns The Famix repository containing the Famix model
+     */
+    famixRepFromProject(project) {
+        const sourceFileNames = project.getSourceFiles().map(f => f.getFilePath());
+        const famixRep = this.famixRepFromPaths(sourceFileNames);
+        return famixRep;
+    }
+}
+exports.Importer = Importer;

package/dist/analyze_functions/processAccesses.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessAccesses = void 0;
+/**
+ * This class is used to build a Famix model for the accesses
+ */
+class ProcessAccesses {
+    /**
+     * Initializes the ProcessAccesses object
+     * @param famixFunctions FamixFunctions object, it contains all the functions needed to create Famix entities
+     */
+    constructor(famixFunctions) {
+        this.famixFunctions = famixFunctions;
+    }
+    /**
+     * Builds a Famix model for the accesses on the parameters, variables, properties and enum members of the source files
+     * @param accesses A map of parameters, variables, properties and enum members with their id
+     */
+    processAccesses(accesses) {
+        console.info(`processAccesses: Creating accesses:`);
+        accesses.forEach((v, id) => {
+            console.info(`processAccesses: Accesses to ${v.getName()}`);
+            try {
+                const temp_nodes = v.findReferencesAsNodes();
+                temp_nodes.forEach(node => this.processNodeForAccesses(node, id));
+            }
+            catch (error) {
+                console.error(`> WARNING: got exception ${error}. Continuing...`);
+            }
+        });
+    }
+    /**
+     * 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
+     */
+    processNodeForAccesses(n, id) {
+        try {
+            this.famixFunctions.createFamixAccess(n, id);
+            console.info(`processNodeForAccesses: node: node, (${n.getType().getText()})`);
+        }
+        catch (error) {
+            console.error(`> WARNING: got exception ${error}. ScopeDeclaration invalid for ${n.getSymbol().getFullyQualifiedName()}. Continuing...`);
+        }
+    }
+}
+exports.ProcessAccesses = ProcessAccesses;

package/dist/analyze_functions/processFiles.js

@@ -0,0 +1,540 @@
+"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.ProcessFiles = 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");
+/**
+ * This class is used to build a Famix model for an array of source files
+ */
+class ProcessFiles {
+    /**
+     * Initializes the ProcessFiles object
+     * @param famixFunctions FamixFunctions object, it contains all the functions needed to create Famix entities
+     */
+    constructor(famixFunctions) {
+        this.methodsAndFunctionsWithId = new Map(); // Maps the Famix method, constructor, getter, setter and function ids to their ts-morph method, constructor, getter, setter or function object
+        this.accesses = new Map(); // Maps the Famix parameter, variable, property and enum value ids to their ts-morph parameter, variable, property or enum member object
+        this.classes = new Array(); // Array of all the classes of the source files
+        this.interfaces = new Array(); // Array of all the interfaces of the source files
+        this.modules = new Array(); // Array of all the source files which are modules
+        this.exports = new Array(); // Array of all the exports
+        this.famixFunctions = famixFunctions;
+    }
+    /**
+     * Builds a Famix model for an array of source files
+     * @param sourceFiles An array of source files
+     */
+    processFiles(sourceFiles) {
+        sourceFiles.forEach(file => {
+            console.info(`processFiles: File: >>>>>>>>>> ${file.getBaseName()}`);
+            // Computes the cyclomatic complexity metrics for the current source file
+            this.currentCC = (0, cyclomatic_service_1.calculate)(file.getFilePath());
+            this.processFile(file);
+        });
+    }
+    /**
+     * Gets the map of methods and functions with their id
+     * @returns The map of methods and functions with their id
+     */
+    getMethodsAndFunctionsWithId() {
+        return this.methodsAndFunctionsWithId;
+    }
+    /**
+     * Gets the map of accesses
+     * @returns The map of accesses
+     */
+    getAccesses() {
+        return this.accesses;
+    }
+    /**
+     * Gets the array of classes
+     * @returns The array of classes
+     */
+    getClasses() {
+        return this.classes;
+    }
+    /**
+     * Gets the array of interfaces
+     * @returns The array of interfaces
+     */
+    getInterfaces() {
+        return this.interfaces;
+    }
+    /**
+     * Gets the array of modules
+     * @returns The array of modules
+     */
+    getModules() {
+        return this.modules;
+    }
+    /**
+     * Gets the array of exports
+     * @returns The array of exports
+     */
+    getExports() {
+        return this.exports;
+    }
+    /**
+     * Builds a Famix model for a source file
+     * @param f A source file
+     */
+    processFile(f) {
+        const isModule = this.isModule(f);
+        if (isModule) {
+            this.modules.push(f);
+        }
+        const fmxFile = this.famixFunctions.createOrGetFamixFile(f, isModule);
+        console.info(`processFile: file: ${f.getBaseName()}, fqn = ${fmxFile.getFullyQualifiedName()}`);
+        this.processComments(f, fmxFile);
+        this.processAliases(f, fmxFile);
+        this.processClasses(f, fmxFile);
+        this.processInterfaces(f, fmxFile);
+        this.processVariables(f, fmxFile);
+        this.processEnums(f, fmxFile);
+        this.processFunctions(f, fmxFile);
+        this.processNamespaces(f, fmxFile);
+    }
+    /**
+     * Builds a Famix model for a namespace
+     * @param m A namespace
+     * @returns A Famix.Namespace representing the namespace
+     */
+    processNamespace(m) {
+        const fmxNamespace = this.famixFunctions.createOrGetFamixNamespace(m);
+        console.info(`processNamespace: namespace: ${m.getName()}, (${m.getType().getText()}), ${fmxNamespace.getFullyQualifiedName()}`);
+        this.processComments(m, fmxNamespace);
+        this.processAliases(m, fmxNamespace);
+        this.processClasses(m, fmxNamespace);
+        this.processInterfaces(m, fmxNamespace);
+        this.processVariables(m, fmxNamespace);
+        this.processEnums(m, fmxNamespace);
+        this.processFunctions(m, fmxNamespace);
+        this.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
+     */
+    processAliases(m, fmxScope) {
+        console.info(`processAliases: ---------- Finding Aliases:`);
+        m.getTypeAliases().forEach(a => {
+            const fmxAlias = this.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
+     */
+    processClasses(m, fmxScope) {
+        console.info(`processClasses: ---------- Finding Classes:`);
+        m.getClasses().forEach(c => {
+            const fmxClass = this.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
+     */
+    processInterfaces(m, fmxScope) {
+        console.info(`processInterfaces: ---------- Finding Interfaces:`);
+        m.getInterfaces().forEach(i => {
+            const fmxInterface = this.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
+     */
+    processVariables(m, fmxScope) {
+        console.info(`processVariables: ---------- Finding Variables:`);
+        m.getVariableStatements().forEach(v => {
+            const fmxVariables = this.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
+     */
+    processEnums(m, fmxScope) {
+        console.info(`processEnums: ---------- Finding Enums:`);
+        m.getEnums().forEach(e => {
+            const fmxEnum = this.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
+     */
+    processFunctions(m, fmxScope) {
+        console.info(`processFunctions: ---------- Finding Functions:`);
+        m.getFunctions().forEach(f => {
+            const fmxFunction = this.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
+     */
+    processNamespaces(m, fmxScope) {
+        console.info(`processNamespaces: ---------- Finding Namespaces:`);
+        m.getModules().forEach(md => {
+            const fmxNsp = this.processNamespace(md);
+            fmxScope.addNamespace(fmxNsp);
+        });
+    }
+    /**
+     * Builds a Famix model for an alias
+     * @param a An alias
+     * @returns A Famix.Alias representing the alias
+     */
+    processAlias(a) {
+        const fmxAlias = this.famixFunctions.createFamixAlias(a);
+        console.info(`processAlias: alias: ${a.getName()}, (${a.getType().getText()}), fqn = ${fmxAlias.getFullyQualifiedName()}`);
+        this.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
+     */
+    processClass(c) {
+        this.classes.push(c);
+        const fmxClass = this.famixFunctions.createOrGetFamixClass(c);
+        console.info(`processClass: class: ${c.getName()}, (${c.getType().getText()}), fqn = ${fmxClass.getFullyQualifiedName()}`);
+        this.processComments(c, fmxClass);
+        this.processDecorators(c, fmxClass);
+        this.processStructuredType(c, fmxClass);
+        c.getConstructors().forEach(con => {
+            const fmxCon = this.processMethod(con);
+            fmxClass.addMethod(fmxCon);
+        });
+        c.getGetAccessors().forEach(acc => {
+            const fmxAcc = this.processMethod(acc);
+            fmxClass.addMethod(fmxAcc);
+        });
+        c.getSetAccessors().forEach(acc => {
+            const fmxAcc = this.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
+     */
+    processInterface(i) {
+        this.interfaces.push(i);
+        const fmxInterface = this.famixFunctions.createOrGetFamixInterface(i);
+        console.info(`processInterface: interface: ${i.getName()}, (${i.getType().getText()}), fqn = ${fmxInterface.getFullyQualifiedName()}`);
+        this.processComments(i, fmxInterface);
+        this.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
+     */
+    processStructuredType(c, fmxScope) {
+        console.info(`processStructuredType: ---------- Finding Properties and Methods:`);
+        if (fmxScope instanceof Famix.ParameterizableClass || fmxScope instanceof Famix.ParameterizableInterface) {
+            this.processTypeParameters(c, fmxScope);
+        }
+        c.getProperties().forEach(prop => {
+            const fmxProperty = this.processProperty(prop);
+            fmxScope.addProperty(fmxProperty);
+        });
+        c.getMethods().forEach(m => {
+            const fmxMethod = this.processMethod(m);
+            fmxScope.addMethod(fmxMethod);
+        });
+    }
+    /**
+     * Builds a Famix model for a property
+     * @param p A property
+     * @returns A Famix.Property representing the property
+     */
+    processProperty(p) {
+        const fmxProperty = this.famixFunctions.createFamixProperty(p);
+        console.info(`processProperty: property: ${p.getName()}, (${p.getType().getText()}), fqn = ${fmxProperty.getFullyQualifiedName()}`);
+        this.processComments(p, fmxProperty);
+        if (!(p instanceof ts_morph_1.PropertySignature)) {
+            this.processDecorators(p, fmxProperty);
+            this.accesses.set(fmxProperty.id, p);
+        }
+        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
+     */
+    processMethod(m) {
+        const fmxMethod = this.famixFunctions.createFamixMethod(m, this.currentCC);
+        console.info(`processMethod: method: ${!(m instanceof ts_morph_1.ConstructorDeclaration) ? m.getName() : "constructor"}, (${m.getType().getText()}), parent: ${m.getParent().getName()}, fqn = ${fmxMethod.getFullyQualifiedName()}`);
+        this.processComments(m, fmxMethod);
+        this.processTypeParameters(m, fmxMethod);
+        this.processParameters(m, fmxMethod);
+        if (!(m instanceof ts_morph_1.MethodSignature)) {
+            this.processAliases(m, fmxMethod);
+            this.processVariables(m, fmxMethod);
+            this.processEnums(m, fmxMethod);
+            this.processFunctions(m, fmxMethod);
+            this.processFunctionExpressions(m, fmxMethod);
+            this.methodsAndFunctionsWithId.set(fmxMethod.id, m);
+        }
+        if (m instanceof ts_morph_1.MethodDeclaration || m instanceof ts_morph_1.GetAccessorDeclaration || m instanceof ts_morph_1.SetAccessorDeclaration) {
+            this.processDecorators(m, fmxMethod);
+        }
+        return fmxMethod;
+    }
+    /**
+     * Builds a Famix model for a function
+     * @param f A function
+     * @returns A Famix.Function representing the function
+     */
+    processFunction(f) {
+        const fmxFunction = this.famixFunctions.createFamixFunction(f, this.currentCC);
+        console.info(`processFunction: function: ${(f.getName()) ? f.getName() : "anonymous"}, (${f.getType().getText()}), fqn = ${fmxFunction.getFullyQualifiedName()}`);
+        this.processComments(f, fmxFunction);
+        this.processAliases(f, fmxFunction);
+        this.processTypeParameters(f, fmxFunction);
+        this.processParameters(f, fmxFunction);
+        this.processVariables(f, fmxFunction);
+        this.processEnums(f, fmxFunction);
+        this.processFunctions(f, fmxFunction);
+        if (f instanceof ts_morph_1.FunctionDeclaration && !(f.getParent() instanceof ts_morph_1.Block)) {
+            this.processFunctionExpressions(f, fmxFunction);
+        }
+        this.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
+     */
+    processFunctionExpressions(f, fmxScope) {
+        console.info(`processFunctionExpressions: ---------- Finding Function Expressions:`);
+        const functionExpressions = f.getDescendantsOfKind(ts_morph_1.SyntaxKind.FunctionExpression);
+        functionExpressions.forEach((func) => {
+            const fmxFunc = this.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
+     */
+    processParameters(m, fmxScope) {
+        console.info(`processParameters: ---------- Finding Parameters:`);
+        m.getParameters().forEach(param => {
+            const fmxParam = this.processParameter(param);
+            fmxScope.addParameter(fmxParam);
+        });
+    }
+    /**
+     * Builds a Famix model for a parameter
+     * @param p A parameter
+     * @returns A Famix.Parameter representing the parameter
+     */
+    processParameter(p) {
+        const fmxParam = this.famixFunctions.createFamixParameter(p);
+        console.info(`processParameter: parameter: ${p.getName()}, (${p.getType().getText()}), fqn = ${fmxParam.getFullyQualifiedName()}`);
+        this.processComments(p, fmxParam);
+        this.processDecorators(p, fmxParam);
+        const parent = p.getParent();
+        if (!(parent instanceof ts_morph_1.MethodSignature)) {
+            this.accesses.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
+     */
+    processTypeParameters(e, fmxScope) {
+        console.info(`processTypeParameters: ---------- Finding Type Parameters:`);
+        e.getTypeParameters().forEach(tp => {
+            const fmxParam = this.processTypeParameter(tp);
+            fmxScope.addTypeParameter(fmxParam);
+        });
+    }
+    /**
+     * Builds a Famix model for a type parameter
+     * @param tp A type parameter
+     * @returns A Famix.TypeParameter representing the type parameter
+     */
+    processTypeParameter(tp) {
+        const fmxTypeParameter = this.famixFunctions.createFamixTypeParameter(tp);
+        console.info(`processTypeParameter: type parameter: ${tp.getName()}, (${tp.getType().getText()}), fqn = ${fmxTypeParameter.getFullyQualifiedName()}`);
+        this.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
+     */
+    processVariableStatement(v) {
+        const fmxVariables = new Array();
+        console.info(`processVariableStatement: variable statement: variable statement, (${v.getType().getText()}), ${v.getDeclarationKindKeyword().getText()}`);
+        v.getDeclarations().forEach(variable => {
+            const fmxVar = this.processVariable(variable);
+            this.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
+     */
+    processVariable(v) {
+        const fmxVar = this.famixFunctions.createFamixVariable(v);
+        console.info(`processVariable: variable: ${v.getName()}, (${v.getType().getText()}), ${v.getInitializer() ? "initializer: " + v.getInitializer().getText() : "initializer: "}, fqn = ${fmxVar.getFullyQualifiedName()}`);
+        this.processComments(v, fmxVar);
+        this.accesses.set(fmxVar.id, v);
+        return fmxVar;
+    }
+    /**
+     * Builds a Famix model for an enum
+     * @param e An enum
+     * @returns A Famix.Enum representing the enum
+     */
+    processEnum(e) {
+        const fmxEnum = this.famixFunctions.createFamixEnum(e);
+        console.info(`processEnum: enum: ${e.getName()}, (${e.getType().getText()}), fqn = ${fmxEnum.getFullyQualifiedName()}`);
+        this.processComments(e, fmxEnum);
+        e.getMembers().forEach(m => {
+            const fmxEnumValue = this.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
+     */
+    processEnumValue(v) {
+        const fmxEnumValue = this.famixFunctions.createFamixEnumValue(v);
+        console.info(`processEnumValue: enum value: ${v.getName()}, (${v.getType().getText()}), fqn = ${fmxEnumValue.getFullyQualifiedName()}`);
+        this.processComments(v, fmxEnumValue);
+        this.accesses.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
+     */
+    processDecorators(e, fmxScope) {
+        console.info(`processDecorators: ---------- Finding Decorators:`);
+        e.getDecorators().forEach(dec => {
+            const fmxDec = this.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
+     */
+    processDecorator(d, e) {
+        const fmxDec = this.famixFunctions.createOrGetFamixDecorator(d, e);
+        console.info(`processDecorator: decorator: ${d.getName()}, (${d.getType().getText()}), fqn = ${fmxDec.getFullyQualifiedName()}`);
+        this.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
+     */
+    processComments(e, fmxScope) {
+        console.info(`processComments: ---------- Finding Comments:`);
+        e.getLeadingCommentRanges().forEach(c => {
+            const fmxComment = this.processComment(c, fmxScope);
+            fmxScope.addComment(fmxComment);
+        });
+        e.getTrailingCommentRanges().forEach(c => {
+            const fmxComment = this.processComment(c, fmxScope);
+            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
+     */
+    processComment(c, fmxScope) {
+        let isJSDoc = false;
+        if (c.getText().substring(0, 3) === "/**") {
+            isJSDoc = true;
+        }
+        const fmxComment = this.famixFunctions.createFamixComment(c, fmxScope, isJSDoc);
+        console.info(`processComment: comment: ${c.getText()}`);
+        return fmxComment;
+    }
+    /**
+     * 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
+     */
+    isModule(sourceFile) {
+        if (sourceFile.getImportDeclarations().length > 0 || sourceFile.getExportedDeclarations().size > 0) {
+            this.exports.push(sourceFile.getExportedDeclarations());
+            return true;
+        }
+        return false;
+    }
+}
+exports.ProcessFiles = ProcessFiles;