ts2famix 1.0.1 → 1.0.4

package/dist/famix_functions/famix_functions_associations.js

@@ -0,0 +1,205 @@
+"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.FamixFunctionsAssociations = void 0;
+const ts_morph_1 = require("ts-morph");
+const Famix = __importStar(require("../lib/famix/src/model/famix"));
+const fqn_1 = require("../fqn");
+const famix_functions_index_1 = require("./famix_functions_index");
+/**
+ * This class is used to build a Famix model for the associations
+ */
+class FamixFunctionsAssociations {
+    /**
+     * Initializes the FamixFunctionsAssociations object
+     * @param famixRep The Famix repository
+     * @param fmxClasses The map of the class names and their Famix model
+     * @param fmxInterfaces The map of the interface names and their Famix model
+     */
+    constructor(famixRep, fmxClasses, fmxInterfaces) {
+        this.FQNFunctions = new fqn_1.FQNFunctions(); // The fully qualified name functions
+        this.famixRep = famixRep;
+        this.famixClasses = fmxClasses;
+        this.famixInterfaces = fmxInterfaces;
+        this.famixFunctionsIndex = new famix_functions_index_1.FamixFunctionsIndex(famixRep);
+    }
+    /**
+     * Creates a Famix access
+     * @param node A node
+     * @param id An id of a parameter, a variable, a property or an enum member
+     */
+    createFamixAccess(node, id) {
+        const fmxVar = this.famixRep.getFamixEntityById(id);
+        const nodeReferenceAncestor = this.findAncestor(node);
+        const ancestorFullyQualifiedName = this.FQNFunctions.getFQN(nodeReferenceAncestor);
+        const accessor = this.getFamixEntityByFullyQualifiedName(ancestorFullyQualifiedName);
+        const fmxAccess = new Famix.Access(this.famixRep);
+        fmxAccess.setAccessor(accessor);
+        fmxAccess.setVariable(fmxVar);
+        this.famixFunctionsIndex.makeFamixIndexFileAnchor(node, fmxAccess);
+    }
+    /**
+     * Creates a Famix invocation
+     * @param node A node
+     * @param m A method or a function
+     * @param id The id of the method or the function
+     */
+    createFamixInvocation(node, m, id) {
+        const fmxMethodOrFunction = this.getFamixEntityById(id);
+        const nodeReferenceAncestor = this.findAncestor(node);
+        const ancestorFullyQualifiedName = this.FQNFunctions.getFQN(nodeReferenceAncestor);
+        const sender = this.getFamixEntityByFullyQualifiedName(ancestorFullyQualifiedName);
+        const receiverFullyQualifiedName = this.FQNFunctions.getFQN(m.getParent());
+        const receiver = this.getFamixEntityByFullyQualifiedName(receiverFullyQualifiedName);
+        const fmxInvocation = new Famix.Invocation(this.famixRep);
+        fmxInvocation.setSender(sender);
+        fmxInvocation.setReceiver(receiver);
+        fmxInvocation.addCandidate(fmxMethodOrFunction);
+        fmxInvocation.setSignature(fmxMethodOrFunction.getSignature());
+        this.famixFunctionsIndex.makeFamixIndexFileAnchor(node, fmxInvocation);
+    }
+    /**
+     * Creates a Famix inheritance
+     * @param cls A class or an interface (subclass)
+     * @param inhClass The inherited class or interface (superclass)
+     */
+    createFamixInheritance(cls, inhClass) {
+        const fmxInheritance = new Famix.Inheritance(this.famixRep);
+        const clsName = cls.getName();
+        let subClass;
+        if (cls instanceof ts_morph_1.ClassDeclaration) {
+            subClass = this.famixClasses.get(clsName);
+        }
+        else {
+            subClass = this.famixInterfaces.get(clsName);
+        }
+        let inhClassName;
+        let superClass;
+        if (inhClass instanceof ts_morph_1.ClassDeclaration || inhClass instanceof ts_morph_1.InterfaceDeclaration) {
+            inhClassName = inhClass.getName();
+            if (inhClass instanceof ts_morph_1.ClassDeclaration) {
+                superClass = this.famixClasses.get(inhClassName);
+            }
+            else {
+                superClass = this.famixInterfaces.get(inhClassName);
+            }
+        }
+        else {
+            inhClassName = inhClass.getExpression().getText();
+        }
+        if (superClass === undefined) {
+            if (inhClass instanceof ts_morph_1.ClassDeclaration) {
+                superClass = new Famix.Class(this.famixRep);
+                this.famixClasses.set(inhClassName, superClass);
+            }
+            else {
+                superClass = new Famix.Interface(this.famixRep);
+                this.famixInterfaces.set(inhClassName, superClass);
+            }
+            superClass.setName(inhClassName);
+            superClass.setIsStub(true);
+            this.famixFunctionsIndex.makeFamixIndexFileAnchor(inhClass, superClass);
+        }
+        fmxInheritance.setSubclass(subClass);
+        fmxInheritance.setSuperclass(superClass);
+        this.famixFunctionsIndex.makeFamixIndexFileAnchor(null, fmxInheritance);
+    }
+    /**
+     * Creates a Famix import clause
+     * @param importer A source file which is a module
+     * @param moduleSpecifier The name of the module where the export declaration is
+     * @param moduleSpecifierFilePath The path of the module where the export declaration is
+     * @param importElement The imported entity
+     * @param isInExports A boolean indicating if the imported entity is in the exports
+     * @param isDefaultExport A boolean indicating if the imported entity is a default export
+     */
+    createFamixImportClause(importer, moduleSpecifier, moduleSpecifierFilePath, importElement, isInExports, isDefaultExport) {
+        const fmxImportClause = new Famix.ImportClause(this.famixRep);
+        let importedEntity;
+        let importedEntityName;
+        let pathName = "\"" + moduleSpecifierFilePath + "\".";
+        if (importElement instanceof ts_morph_1.ImportSpecifier) {
+            importedEntityName = importElement.getName();
+            pathName = pathName + importedEntityName;
+            if (isInExports) {
+                importedEntity = this.getFamixEntityByFullyQualifiedName(pathName);
+            }
+            if (importedEntity === undefined) {
+                importedEntity = new Famix.NamedEntity(this.famixRep);
+                importedEntity.setName(importedEntityName);
+                if (!isInExports) {
+                    importedEntity.setIsStub(true);
+                }
+                this.famixFunctionsIndex.makeFamixIndexFileAnchor(importElement, importedEntity);
+                importedEntity.setFullyQualifiedName(pathName);
+            }
+        }
+        else {
+            importedEntityName = importElement.getText();
+            if (isDefaultExport) {
+                pathName = pathName + "defaultExport";
+            }
+            else {
+                pathName = pathName + "namespaceExport";
+            }
+            importedEntity = new Famix.NamedEntity(this.famixRep);
+            importedEntity.setName(importedEntityName);
+            this.famixFunctionsIndex.makeFamixIndexFileAnchor(importElement, importedEntity);
+            importedEntity.setFullyQualifiedName(pathName);
+        }
+        const importerFullyQualifiedName = this.FQNFunctions.getFQN(importer);
+        const fmxImporter = this.getFamixEntityByFullyQualifiedName(importerFullyQualifiedName);
+        fmxImportClause.setImporter(fmxImporter);
+        fmxImportClause.setImportedEntity(importedEntity);
+        fmxImportClause.setModuleSpecifier(moduleSpecifier);
+        this.famixFunctionsIndex.makeFamixIndexFileAnchor(null, fmxImportClause);
+        fmxImporter.addImportClause(fmxImportClause);
+    }
+    /**
+     * Gets a Famix entity by id
+     * @param famixId An id of a Famix entity
+     * @returns The Famix entity corresponding to the id
+     */
+    getFamixEntityById(famixId) {
+        return this.famixRep.getFamixEntityById(famixId);
+    }
+    /**
+     * Gets a Famix entity by fully qualified name
+     * @param fullyQualifiedName A fully qualified name
+     * @returns The Famix entity corresponding to the fully qualified name
+     */
+    getFamixEntityByFullyQualifiedName(fullyQualifiedName) {
+        return this.famixRep.getFamixEntityByFullyQualifiedName(fullyQualifiedName);
+    }
+    /**
+     * Finds the ancestor of a node
+     * @param node A node
+     * @returns The ancestor of the node
+     */
+    findAncestor(node) {
+        return node.getAncestors().find(a => a.getKind() === ts_morph_1.SyntaxKind.MethodDeclaration || a.getKind() === ts_morph_1.SyntaxKind.Constructor || a.getKind() === ts_morph_1.SyntaxKind.FunctionDeclaration || a.getKind() === ts_morph_1.SyntaxKind.FunctionExpression || a.getKind() === ts_morph_1.SyntaxKind.ModuleDeclaration || a.getKind() === ts_morph_1.SyntaxKind.SourceFile || a.getKindName() === "GetAccessor" || a.getKindName() === "SetAccessor" || a.getKind() === ts_morph_1.SyntaxKind.ClassDeclaration);
+    }
+}
+exports.FamixFunctionsAssociations = FamixFunctionsAssociations;

package/dist/famix_functions/famix_functions_index.js

@@ -0,0 +1,62 @@
+"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.FamixFunctionsIndex = void 0;
+const ts_morph_1 = require("ts-morph");
+const Famix = __importStar(require("../lib/famix/src/model/famix"));
+const fqn_1 = require("../fqn");
+/**
+ * This class is used to build a Famix model for the index file anchors
+ */
+class FamixFunctionsIndex {
+    /**
+     * Initializes the FamixFunctionsIndex object
+     * @param famixRep The Famix repository
+     */
+    constructor(famixRep) {
+        this.FQNFunctions = new fqn_1.FQNFunctions(); // The fully qualified name functions
+        this.famixRep = famixRep;
+    }
+    /**
+     * Makes a Famix index file anchor
+     * @param sourceElement A source element
+     * @param famixElement The Famix model of the source element
+     */
+    makeFamixIndexFileAnchor(sourceElement, famixElement) {
+        const fmxIndexFileAnchor = new Famix.IndexedFileAnchor(this.famixRep);
+        fmxIndexFileAnchor.setElement(famixElement);
+        if (sourceElement !== null) {
+            fmxIndexFileAnchor.setFileName(sourceElement.getSourceFile().getFilePath());
+            if (!(sourceElement instanceof ts_morph_1.CommentRange)) {
+                fmxIndexFileAnchor.setStartPos(sourceElement.getStart());
+                fmxIndexFileAnchor.setEndPos(sourceElement.getEnd());
+            }
+            if (!(famixElement instanceof Famix.Association) && !(famixElement instanceof Famix.Comment) && !(sourceElement instanceof ts_morph_1.CommentRange) && !(sourceElement instanceof ts_morph_1.Identifier) && !(sourceElement instanceof ts_morph_1.ImportSpecifier) && !(sourceElement instanceof ts_morph_1.ExpressionWithTypeArguments)) {
+                famixElement.setFullyQualifiedName(this.FQNFunctions.getFQN(sourceElement));
+            }
+        }
+    }
+}
+exports.FamixFunctionsIndex = FamixFunctionsIndex;

package/dist/famix_functions/famix_functions_types.js

@@ -0,0 +1,110 @@
+"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.FamixFunctionsTypes = void 0;
+const ts_morph_1 = require("ts-morph");
+const Famix = __importStar(require("../lib/famix/src/model/famix"));
+const fqn_1 = require("../fqn");
+const famix_functions_index_1 = require("./famix_functions_index");
+/**
+ * This class is used to build a Famix model for the types
+ */
+class FamixFunctionsTypes {
+    /**
+     * Initializes the FamixFunctionsIndex object
+     * @param famixRep The Famix repository
+     */
+    constructor(famixRep) {
+        this.FQNFunctions = new fqn_1.FQNFunctions(); // The fully qualified name functions
+        this.fmxTypes = new Map(); // Maps the type names to their Famix model
+        this.famixRep = famixRep;
+        this.famixFunctionsIndex = new famix_functions_index_1.FamixFunctionsIndex(famixRep);
+    }
+    /**
+     * Creates or gets a Famix type
+     * @param typeName A type name
+     * @param element A ts-morph element
+     * @returns The Famix model of the type
+     */
+    createOrGetFamixType(typeName, element) {
+        let fmxType;
+        let isPrimitiveType = false;
+        let isParameterizedType = false;
+        const typeAncestor = this.findTypeAncestor(element);
+        const ancestorFullyQualifiedName = this.FQNFunctions.getFQN(typeAncestor);
+        const ancestor = this.getFamixEntityByFullyQualifiedName(ancestorFullyQualifiedName);
+        if (typeName === "number" || typeName === "string" || typeName === "boolean" || typeName === "bigint" || typeName === "symbol" || typeName === "undefined" || typeName === "null") {
+            isPrimitiveType = true;
+        }
+        if (!isPrimitiveType && typeName.includes("<") && typeName.includes(">") && !(typeName.includes("=>"))) {
+            isParameterizedType = true;
+        }
+        if (!this.fmxTypes.has(typeName)) {
+            if (isPrimitiveType) {
+                fmxType = new Famix.PrimitiveType(this.famixRep);
+                fmxType.setIsStub(true);
+            }
+            else if (isParameterizedType) {
+                fmxType = new Famix.ParameterizedType(this.famixRep);
+                const parameterTypeNames = typeName.substring(typeName.indexOf("<") + 1, typeName.indexOf(">")).split(",").map(s => s.trim());
+                const baseTypeName = typeName.substring(0, typeName.indexOf("<")).trim();
+                parameterTypeNames.forEach(parameterTypeName => {
+                    const fmxParameterType = this.createOrGetFamixType(parameterTypeName, element);
+                    fmxType.addArgument(fmxParameterType);
+                });
+                const fmxBaseType = this.createOrGetFamixType(baseTypeName, element);
+                fmxType.setBaseType(fmxBaseType);
+            }
+            else {
+                fmxType = new Famix.Type(this.famixRep);
+            }
+            fmxType.setName(typeName);
+            fmxType.setContainer(ancestor);
+            this.famixFunctionsIndex.makeFamixIndexFileAnchor(null, fmxType);
+            this.fmxTypes.set(typeName, fmxType);
+        }
+        else {
+            fmxType = this.fmxTypes.get(typeName);
+        }
+        return fmxType;
+    }
+    /**
+     * Gets a Famix entity by fully qualified name
+     * @param fullyQualifiedName A fully qualified name
+     * @returns The Famix entity corresponding to the fully qualified name
+     */
+    getFamixEntityByFullyQualifiedName(fullyQualifiedName) {
+        return this.famixRep.getFamixEntityByFullyQualifiedName(fullyQualifiedName);
+    }
+    /**
+     * Finds the ancestor of a ts-morph element
+     * @param element A ts-morph element
+     * @returns The ancestor of the ts-morph element
+     */
+    findTypeAncestor(element) {
+        return element.getAncestors().find(a => a.getKind() === ts_morph_1.SyntaxKind.MethodDeclaration || a.getKind() === ts_morph_1.SyntaxKind.Constructor || a.getKind() === ts_morph_1.SyntaxKind.MethodSignature || a.getKind() === ts_morph_1.SyntaxKind.FunctionDeclaration || a.getKind() === ts_morph_1.SyntaxKind.FunctionExpression || a.getKind() === ts_morph_1.SyntaxKind.ModuleDeclaration || a.getKind() === ts_morph_1.SyntaxKind.SourceFile || a.getKindName() === "GetAccessor" || a.getKindName() === "SetAccessor" || a.getKind() === ts_morph_1.SyntaxKind.ClassDeclaration || a.getKind() === ts_morph_1.SyntaxKind.InterfaceDeclaration);
+    }
+}
+exports.FamixFunctionsTypes = FamixFunctionsTypes;

package/dist/fqn.js

@@ -0,0 +1,126 @@
+"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.FQNFunctions = void 0;
+const ts = __importStar(require("ts-morph"));
+/**
+ * This class is used to get the fully qualified name of a node
+ */
+class FQNFunctions {
+    /**
+     * Gets the fully qualified name of a node, if it has one
+     * @param node A node
+     * @returns The fully qualified name of the node, or undefined if it doesn't have one
+     */
+    getFQN(node) {
+        if (node instanceof ts.SourceFile) {
+            return `"${node.getFilePath()}"`;
+        }
+        const symbol = node.getSymbol();
+        if (!symbol) {
+            return undefined;
+        }
+        const declarations = symbol.getDeclarations();
+        if (!declarations) {
+            return undefined;
+        }
+        const sourceFile = declarations[0].getSourceFile();
+        if (!sourceFile) {
+            return undefined;
+        }
+        const sourceFilePath = sourceFile.getFilePath();
+        const sourceFileDirectory = sourceFilePath.substring(0, sourceFilePath.lastIndexOf("/"));
+        const qualifiedNameParts = [];
+        const nodeName = this.getNameOfNode(node);
+        if (nodeName)
+            qualifiedNameParts.push(nodeName);
+        const ancestors = node.getAncestors();
+        ancestors.forEach(a => {
+            const partName = this.getNameOfNode(a);
+            if (partName)
+                qualifiedNameParts.push(partName);
+        });
+        if (qualifiedNameParts.length > 0) {
+            return `"${sourceFileDirectory}/${qualifiedNameParts.pop()}".${qualifiedNameParts.reverse().join(".")}`;
+        }
+        else {
+            return undefined;
+        }
+    }
+    /**
+     * Gets the name of a node, if it has one
+     * @param a A node
+     * @returns The name of the node, or an empty string if it doesn't have one
+     */
+    getNameOfNode(a) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
+        switch (a.getKind()) {
+            case ts.SyntaxKind.SourceFile:
+                return (_a = a.asKind(ts.SyntaxKind.SourceFile)) === null || _a === void 0 ? void 0 : _a.getBaseName();
+            case ts.SyntaxKind.ModuleDeclaration:
+                return (_b = a.asKind(ts.SyntaxKind.ModuleDeclaration)) === null || _b === void 0 ? void 0 : _b.getName();
+            case ts.SyntaxKind.ClassDeclaration:
+                return (_c = a.asKind(ts.SyntaxKind.ClassDeclaration)) === null || _c === void 0 ? void 0 : _c.getName();
+            case ts.SyntaxKind.InterfaceDeclaration:
+                return (_d = a.asKind(ts.SyntaxKind.InterfaceDeclaration)) === null || _d === void 0 ? void 0 : _d.getName();
+            case ts.SyntaxKind.PropertyDeclaration:
+                return (_e = a.asKind(ts.SyntaxKind.PropertyDeclaration)) === null || _e === void 0 ? void 0 : _e.getName();
+            case ts.SyntaxKind.PropertySignature:
+                return (_f = a.asKind(ts.SyntaxKind.PropertySignature)) === null || _f === void 0 ? void 0 : _f.getName();
+            case ts.SyntaxKind.MethodDeclaration:
+                return (_g = a.asKind(ts.SyntaxKind.MethodDeclaration)) === null || _g === void 0 ? void 0 : _g.getName();
+            case ts.SyntaxKind.MethodSignature:
+                return (_h = a.asKind(ts.SyntaxKind.MethodSignature)) === null || _h === void 0 ? void 0 : _h.getName();
+            case ts.SyntaxKind.GetAccessor:
+                return (_j = a.asKind(ts.SyntaxKind.GetAccessor)) === null || _j === void 0 ? void 0 : _j.getName();
+            case ts.SyntaxKind.SetAccessor:
+                return (_k = a.asKind(ts.SyntaxKind.SetAccessor)) === null || _k === void 0 ? void 0 : _k.getName();
+            case ts.SyntaxKind.FunctionDeclaration:
+                return (_l = a.asKind(ts.SyntaxKind.FunctionDeclaration)) === null || _l === void 0 ? void 0 : _l.getName();
+            case ts.SyntaxKind.FunctionExpression:
+                return ((_m = a.asKind(ts.SyntaxKind.FunctionExpression)) === null || _m === void 0 ? void 0 : _m.getName()) ? (_o = a.asKind(ts.SyntaxKind.FunctionExpression)) === null || _o === void 0 ? void 0 : _o.getName() : "anonymous";
+            case ts.SyntaxKind.Parameter:
+                return (_p = a.asKind(ts.SyntaxKind.Parameter)) === null || _p === void 0 ? void 0 : _p.getName();
+            case ts.SyntaxKind.VariableDeclaration:
+                return (_q = a.asKind(ts.SyntaxKind.VariableDeclaration)) === null || _q === void 0 ? void 0 : _q.getName();
+            case ts.SyntaxKind.Decorator:
+                return "@" + ((_r = a.asKind(ts.SyntaxKind.Decorator)) === null || _r === void 0 ? void 0 : _r.getName());
+            case ts.SyntaxKind.TypeParameter:
+                return (_s = a.asKind(ts.SyntaxKind.TypeParameter)) === null || _s === void 0 ? void 0 : _s.getName();
+            case ts.SyntaxKind.EnumDeclaration:
+                return (_t = a.asKind(ts.SyntaxKind.EnumDeclaration)) === null || _t === void 0 ? void 0 : _t.getName();
+            case ts.SyntaxKind.EnumMember:
+                return (_u = a.asKind(ts.SyntaxKind.EnumMember)) === null || _u === void 0 ? void 0 : _u.getName();
+            case ts.SyntaxKind.TypeAliasDeclaration:
+                return (_v = a.asKind(ts.SyntaxKind.TypeAliasDeclaration)) === null || _v === void 0 ? void 0 : _v.getName();
+            case ts.SyntaxKind.Constructor:
+                return "constructor";
+            default:
+                // ancestor hasn't got a useful name
+                return "";
+        }
+    }
+}
+exports.FQNFunctions = FQNFunctions;

package/dist/fqp_implementation.js

@@ -0,0 +1,73 @@
+"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 });
+const ts = __importStar(require("typescript"));
+function getFullyQualifiedName(node, checker) {
+    // Traverse the lexical hierarchy to construct the fully qualified name.
+    function getQualifiedName(node) {
+        console.log(`getFullyQualifiedName: ${node}`);
+        if (node === undefined) {
+            return undefined;
+        }
+        console.log(`getFullyQualifiedName kind: ${node.kind}, ${ts.SyntaxKind[node.kind]}`);
+        if (ts.isSourceFile(node)) {
+            return undefined;
+        }
+        else if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+            const symbol = checker.getSymbolAtLocation(node.name);
+            if (symbol) {
+                const name = symbol.getName();
+                const parentName = getQualifiedName(node.parent);
+                return parentName ? `${parentName}.${name}` : name;
+            }
+        }
+        return getQualifiedName(node.parent);
+    }
+    return getQualifiedName(node);
+}
+const sourceFile = ts.createSourceFile("test.ts", "function foo() { const x = 1; }", ts.ScriptTarget.ES2015);
+// create a program instance, which is needed to create a type checker
+const program = ts.createProgram(["test.ts"], {});
+const typeChecker = program.getTypeChecker();
+const statements = sourceFile.statements;
+statements.forEach((statement) => {
+    var _a;
+    console.log(`statement: ${statement.kind}`);
+    if (ts.isFunctionDeclaration(statement)) {
+        console.log(`function name: ${(_a = statement.name) === null || _a === void 0 ? void 0 : _a.text}`);
+    }
+});
+// find all the identifiers in the source file (don't use ts.createTypeChecker here, make it work for TS 5.1.x)
+const identifiers = [];
+ts.forEachChild(sourceFile, function walk(node) {
+    if (ts.isIdentifier(node)) {
+        identifiers.push(node);
+    }
+    ts.forEachChild(node, walk);
+});
+console.log(identifiers.map((identifier) => identifier.text).join(", "));
+// find the fully qualified name of each identifier (don't use ts.createTypeChecker here)
+const fullyQualifiedNames = identifiers.map((identifier) => getFullyQualifiedName(identifier, typeChecker));
+console.log(fullyQualifiedNames.join(", "));

package/dist/lib/famix/src/famix_JSON_exporter.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FamixJSONExporter = void 0;
+const famix_base_element_1 = require("./famix_base_element");
+/**
+ * This class is used to export Famix elements to JSON
+ */
+class FamixJSONExporter {
+    /**
+     * Constructor of the FamixJSONExporter class
+     * @param packageClass Name of a Famix class
+     * @param element A Famix element to export, this element is an instance of the class named "packageClass"
+     */
+    constructor(packageClass, element) {
+        this.bufferArray = {}; // A buffer to store the properties of the Famix element
+        this.FamixPrefix = "FamixTypeScript"; // Prefix of the Famix element
+        this.element = element;
+        this.bufferArray["FM3"] = this.FamixPrefix + "." + packageClass;
+        this.bufferArray["id"] = this.element.id;
+    }
+    /**
+     * Adds a property to the Famix element
+     * @param name Name of the property
+     * @param prop A property
+     */
+    addProperty(name, prop) {
+        if (prop instanceof Set) {
+            const valueArray = [];
+            for (const value of Array.from(prop.values())) {
+                if (value instanceof famix_base_element_1.FamixBaseElement) {
+                    valueArray.push({ "ref": value.id });
+                }
+                else {
+                    valueArray.push(value);
+                }
+            }
+            this.bufferArray[name] = valueArray;
+        }
+        else if (prop instanceof famix_base_element_1.FamixBaseElement) {
+            this.bufferArray[name] = { "ref": prop.id };
+        }
+        else if (prop !== undefined && !(prop instanceof Set)) {
+            this.bufferArray[name] = prop;
+        }
+    }
+    /**
+     * Gets a JSON representation of the Famix element
+     * @returns A JSON representation of the Famix element
+     */
+    getJSON() {
+        return JSON.stringify(this.bufferArray);
+    }
+}
+exports.FamixJSONExporter = FamixJSONExporter;

package/dist/lib/famix/src/famix_base_element.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FamixBaseElement = void 0;
+class FamixBaseElement {
+    constructor(repo) {
+        repo.addElement(this);
+    }
+    // @ts-ignore
+    // tslint:disable-next-line:no-empty
+    addPropertiesToExporter(exporter) {
+    }
+}
+exports.FamixBaseElement = FamixBaseElement;