ts2famix 1.0.1

package/src/famix_functions/famix_functions_associations.ts

@@ -0,0 +1,208 @@
+import { ClassDeclaration, ConstructorDeclaration, FunctionDeclaration, Identifier, InterfaceDeclaration, MethodDeclaration, SourceFile, GetAccessorDeclaration, SetAccessorDeclaration, Node, ImportSpecifier, SyntaxKind, FunctionExpression, ExpressionWithTypeArguments } from "ts-morph";
+import * as Famix from "../lib/famix/src/model/famix";
+import { FamixRepository } from "../lib/famix/src/famix_repository";
+import { FQNFunctions } from "../fqn";
+import { FamixFunctionsIndex } from "./famix_functions_index";
+
+/**
+ * This class is used to build a Famix model for the associations
+ */
+export class FamixFunctionsAssociations {
+
+    private famixRep: FamixRepository; // The Famix repository
+    private FQNFunctions = new FQNFunctions(); // The fully qualified name functions
+    private famixClasses: Map<string, Famix.Class | Famix.ParameterizableClass>; // Maps the class names to their Famix model
+    private famixInterfaces: Map<string, Famix.Interface | Famix.ParameterizableInterface>; // Maps the interface names to their Famix model
+    private famixFunctionsIndex: FamixFunctionsIndex; // FamixFunctionsIndex object, it contains all the functions needed to create Famix index file anchors
+
+    /**
+     * 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: FamixRepository, fmxClasses: Map<string, Famix.Class | Famix.ParameterizableClass>, fmxInterfaces: Map<string, Famix.Interface | Famix.ParameterizableInterface>) {
+        this.famixRep = famixRep;
+        this.famixClasses = fmxClasses;
+        this.famixInterfaces = fmxInterfaces;
+        this.famixFunctionsIndex = new 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
+     */
+    public createFamixAccess(node: Identifier, id: number): void {
+        const fmxVar = this.famixRep.getFamixEntityById(id) as Famix.StructuralEntity;
+        const nodeReferenceAncestor = this.findAncestor(node);
+        const ancestorFullyQualifiedName = this.FQNFunctions.getFQN(nodeReferenceAncestor);
+        const accessor = this.getFamixEntityByFullyQualifiedName(ancestorFullyQualifiedName) as Famix.ContainerEntity;
+
+        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
+     */
+    public createFamixInvocation(node: Identifier, m: MethodDeclaration | ConstructorDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | FunctionDeclaration | FunctionExpression, id: number): void {
+        const fmxMethodOrFunction = this.getFamixEntityById(id) as Famix.BehavioralEntity;
+        const nodeReferenceAncestor = this.findAncestor(node);
+        const ancestorFullyQualifiedName = this.FQNFunctions.getFQN(nodeReferenceAncestor);
+        const sender = this.getFamixEntityByFullyQualifiedName(ancestorFullyQualifiedName) as Famix.ContainerEntity;
+        const receiverFullyQualifiedName = this.FQNFunctions.getFQN(m.getParent());
+        const receiver = this.getFamixEntityByFullyQualifiedName(receiverFullyQualifiedName) as Famix.NamedEntity;
+
+        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)
+     */
+    public createFamixInheritance(cls: ClassDeclaration | InterfaceDeclaration, inhClass: ClassDeclaration | InterfaceDeclaration | ExpressionWithTypeArguments): void {
+        const fmxInheritance = new Famix.Inheritance(this.famixRep);
+        const clsName = cls.getName();
+        
+        let subClass: Famix.Class | Famix.Interface;
+        if (cls instanceof ClassDeclaration) {
+            subClass = this.famixClasses.get(clsName);
+        }
+        else {
+            subClass = this.famixInterfaces.get(clsName);
+        }
+        
+        let inhClassName: string;
+        let superClass: Famix.Class | Famix.Interface;
+        if (inhClass instanceof ClassDeclaration || inhClass instanceof InterfaceDeclaration) {
+            inhClassName = inhClass.getName();
+            if (inhClass instanceof ClassDeclaration) {
+                superClass = this.famixClasses.get(inhClassName);
+            }
+            else {
+                superClass = this.famixInterfaces.get(inhClassName);
+            }
+        }
+        else {
+            inhClassName = inhClass.getExpression().getText();
+        }
+
+        if (superClass === undefined) {
+            if (inhClass instanceof 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
+     */
+    public createFamixImportClause(importer: SourceFile, moduleSpecifier: string, moduleSpecifierFilePath: string, importElement: ImportSpecifier | Identifier, isInExports: boolean, isDefaultExport: boolean): void {
+        const fmxImportClause = new Famix.ImportClause(this.famixRep);
+
+        let importedEntity: Famix.NamedEntity;
+        let importedEntityName: string;
+        let pathName = "\"" + moduleSpecifierFilePath + "\".";
+        if (importElement instanceof ImportSpecifier) {
+            importedEntityName = importElement.getName();
+            pathName = pathName + importedEntityName;
+            if (isInExports) {
+                importedEntity = this.getFamixEntityByFullyQualifiedName(pathName) as Famix.NamedEntity;
+            }
+            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) as Famix.Module;
+        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
+     */
+    private getFamixEntityById(famixId: number): Famix.Entity {
+        return this.famixRep.getFamixEntityById(famixId) as Famix.Entity;
+    }
+
+    /**
+     * Gets a Famix entity by fully qualified name
+     * @param fullyQualifiedName A fully qualified name
+     * @returns The Famix entity corresponding to the fully qualified name
+     */
+    private getFamixEntityByFullyQualifiedName(fullyQualifiedName: string): Famix.Entity {
+        return this.famixRep.getFamixEntityByFullyQualifiedName(fullyQualifiedName) as Famix.Entity;
+    }
+    
+    /**
+     * Finds the ancestor of a node
+     * @param node A node
+     * @returns The ancestor of the node
+     */
+    private findAncestor(node: Identifier): Node {
+        return node.getAncestors().find(a => a.getKind() === SyntaxKind.MethodDeclaration || a.getKind() === SyntaxKind.Constructor || a.getKind() === SyntaxKind.FunctionDeclaration || a.getKind() === SyntaxKind.FunctionExpression || a.getKind() === SyntaxKind.ModuleDeclaration || a.getKind() === SyntaxKind.SourceFile || a.getKindName() === "GetAccessor" || a.getKindName() === "SetAccessor" || a.getKind() === SyntaxKind.ClassDeclaration);
+    }
+}

package/src/famix_functions/famix_functions_index.ts

@@ -0,0 +1,44 @@
+import { ClassDeclaration, ConstructorDeclaration, FunctionDeclaration, Identifier, InterfaceDeclaration, MethodDeclaration, MethodSignature, ModuleDeclaration, PropertyDeclaration, PropertySignature, SourceFile, TypeParameterDeclaration, VariableDeclaration, ParameterDeclaration, Decorator, GetAccessorDeclaration, SetAccessorDeclaration, ImportSpecifier, CommentRange, EnumDeclaration, EnumMember, TypeAliasDeclaration, FunctionExpression, ExpressionWithTypeArguments } from "ts-morph";
+import * as Famix from "../lib/famix/src/model/famix";
+import { FamixRepository } from "../lib/famix/src/famix_repository";
+import { FQNFunctions } from "../fqn";
+
+/**
+ * This class is used to build a Famix model for the index file anchors
+ */
+export class FamixFunctionsIndex {
+
+    private famixRep: FamixRepository; // The Famix repository
+    private FQNFunctions = new FQNFunctions(); // The fully qualified name functions
+
+    /**
+     * Initializes the FamixFunctionsIndex object
+     * @param famixRep The Famix repository
+     */
+    constructor(famixRep: FamixRepository) {
+        this.famixRep = famixRep;
+    }
+
+    /**
+     * Makes a Famix index file anchor
+     * @param sourceElement A source element
+     * @param famixElement The Famix model of the source element
+     */
+    public makeFamixIndexFileAnchor(sourceElement: SourceFile | ModuleDeclaration | ClassDeclaration | InterfaceDeclaration | MethodDeclaration | ConstructorDeclaration | MethodSignature | FunctionDeclaration | FunctionExpression | ParameterDeclaration | VariableDeclaration | PropertyDeclaration | PropertySignature | TypeParameterDeclaration | Identifier | Decorator | GetAccessorDeclaration | SetAccessorDeclaration | ImportSpecifier | CommentRange | EnumDeclaration | EnumMember | TypeAliasDeclaration | ExpressionWithTypeArguments, famixElement: Famix.SourcedEntity): void {
+        const fmxIndexFileAnchor = new Famix.IndexedFileAnchor(this.famixRep);
+        fmxIndexFileAnchor.setElement(famixElement);
+
+        if (sourceElement !== null) {
+            fmxIndexFileAnchor.setFileName(sourceElement.getSourceFile().getFilePath());
+            
+            if (!(sourceElement instanceof CommentRange)) {
+                fmxIndexFileAnchor.setStartPos(sourceElement.getStart());
+                fmxIndexFileAnchor.setEndPos(sourceElement.getEnd());
+            }
+
+            if (!(famixElement instanceof Famix.Association) && !(famixElement instanceof Famix.Comment) && !(sourceElement instanceof CommentRange) && !(sourceElement instanceof Identifier) && !(sourceElement instanceof ImportSpecifier) && !(sourceElement instanceof ExpressionWithTypeArguments)) {
+                (famixElement as Famix.NamedEntity).setFullyQualifiedName(this.FQNFunctions.getFQN(sourceElement));
+            }
+        }
+    }
+}

package/src/famix_functions/famix_functions_types.ts

@@ -0,0 +1,100 @@
+import { ConstructorDeclaration, FunctionDeclaration, MethodDeclaration, MethodSignature, PropertyDeclaration, PropertySignature, VariableDeclaration, ParameterDeclaration, GetAccessorDeclaration, SetAccessorDeclaration, EnumMember, TypeAliasDeclaration, Node, SyntaxKind, FunctionExpression } from "ts-morph";
+import * as Famix from "../lib/famix/src/model/famix";
+import { FamixRepository } from "../lib/famix/src/famix_repository";
+import { FQNFunctions } from "../fqn";
+import { FamixFunctionsIndex } from "./famix_functions_index";
+
+/**
+ * This class is used to build a Famix model for the types
+ */
+export class FamixFunctionsTypes {
+
+    private famixRep: FamixRepository; // The Famix repository
+    private FQNFunctions = new FQNFunctions(); // The fully qualified name functions
+    private fmxTypes = new Map<string, Famix.Type | Famix.PrimitiveType | Famix.ParameterizedType>(); // Maps the type names to their Famix model
+    private famixFunctionsIndex: FamixFunctionsIndex; // FamixFunctionsIndex object, it contains all the functions needed to create Famix index file anchors
+
+    /**
+     * Initializes the FamixFunctionsIndex object
+     * @param famixRep The Famix repository
+     */
+    constructor(famixRep: FamixRepository) {
+        this.famixRep = famixRep;
+        this.famixFunctionsIndex = new 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
+     */
+    public createOrGetFamixType(typeName: string, element: TypeAliasDeclaration | PropertyDeclaration | PropertySignature | MethodDeclaration | ConstructorDeclaration | MethodSignature | GetAccessorDeclaration | SetAccessorDeclaration | FunctionDeclaration | FunctionExpression | ParameterDeclaration | VariableDeclaration | EnumMember): Famix.Type | Famix.PrimitiveType | Famix.ParameterizedType {
+        let fmxType: Famix.Type | Famix.PrimitiveType | Famix.ParameterizedType;
+        let isPrimitiveType = false;
+        let isParameterizedType = false;
+
+        const typeAncestor = this.findTypeAncestor(element);
+        const ancestorFullyQualifiedName = this.FQNFunctions.getFQN(typeAncestor);
+        const ancestor = this.getFamixEntityByFullyQualifiedName(ancestorFullyQualifiedName) as Famix.ContainerEntity;
+
+        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 as Famix.ParameterizedType).addArgument(fmxParameterType);
+                });
+                const fmxBaseType = this.createOrGetFamixType(baseTypeName, element);
+                (fmxType as Famix.ParameterizedType).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
+     */
+    private getFamixEntityByFullyQualifiedName(fullyQualifiedName: string): Famix.Entity {
+        return this.famixRep.getFamixEntityByFullyQualifiedName(fullyQualifiedName) as Famix.Entity;
+    }
+
+    /**
+     * Finds the ancestor of a ts-morph element
+     * @param element A ts-morph element
+     * @returns The ancestor of the ts-morph element
+     */
+    private findTypeAncestor(element: TypeAliasDeclaration | PropertyDeclaration | PropertySignature | MethodDeclaration | ConstructorDeclaration | MethodSignature | GetAccessorDeclaration | SetAccessorDeclaration | FunctionDeclaration | FunctionExpression | ParameterDeclaration | VariableDeclaration | EnumMember): Node {
+        return element.getAncestors().find(a => a.getKind() === SyntaxKind.MethodDeclaration || a.getKind() === SyntaxKind.Constructor || a.getKind() === SyntaxKind.MethodSignature || a.getKind() === SyntaxKind.FunctionDeclaration || a.getKind() === SyntaxKind.FunctionExpression || a.getKind() === SyntaxKind.ModuleDeclaration || a.getKind() === SyntaxKind.SourceFile || a.getKindName() === "GetAccessor" || a.getKindName() === "SetAccessor" || a.getKind() === SyntaxKind.ClassDeclaration || a.getKind() === SyntaxKind.InterfaceDeclaration);
+    }
+}

package/src/fqn.ts

@@ -0,0 +1,127 @@
+import * as ts from "ts-morph";
+
+/**
+ * This class is used to get the fully qualified name of a node
+ */
+export 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
+     */
+    public getFQN(node: ts.Node): string {
+        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: Array<string> = [];
+
+        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
+     */
+    private getNameOfNode(a: ts.Node<ts.ts.Node>): string {
+        switch (a.getKind()) {
+            case ts.SyntaxKind.SourceFile:
+                return a.asKind(ts.SyntaxKind.SourceFile)?.getBaseName();
+
+            case ts.SyntaxKind.ModuleDeclaration:
+                return a.asKind(ts.SyntaxKind.ModuleDeclaration)?.getName(); 
+
+            case ts.SyntaxKind.ClassDeclaration:
+                return a.asKind(ts.SyntaxKind.ClassDeclaration)?.getName();
+
+            case ts.SyntaxKind.InterfaceDeclaration:
+                return a.asKind(ts.SyntaxKind.InterfaceDeclaration)?.getName();
+                
+            case ts.SyntaxKind.PropertyDeclaration:
+                return a.asKind(ts.SyntaxKind.PropertyDeclaration)?.getName();    
+
+            case ts.SyntaxKind.PropertySignature:
+                return a.asKind(ts.SyntaxKind.PropertySignature)?.getName();    
+    
+            case ts.SyntaxKind.MethodDeclaration:
+                return a.asKind(ts.SyntaxKind.MethodDeclaration)?.getName();
+
+            case ts.SyntaxKind.MethodSignature:
+                return a.asKind(ts.SyntaxKind.MethodSignature)?.getName();   
+
+            case ts.SyntaxKind.GetAccessor:
+                return a.asKind(ts.SyntaxKind.GetAccessor)?.getName();
+
+            case ts.SyntaxKind.SetAccessor:
+                return a.asKind(ts.SyntaxKind.SetAccessor)?.getName();
+    
+            case ts.SyntaxKind.FunctionDeclaration:
+                return a.asKind(ts.SyntaxKind.FunctionDeclaration)?.getName();
+
+            case ts.SyntaxKind.FunctionExpression:
+                return (a.asKind(ts.SyntaxKind.FunctionExpression)?.getName()) ? a.asKind(ts.SyntaxKind.FunctionExpression)?.getName() : "anonymous";
+            
+            case ts.SyntaxKind.Parameter:
+                return a.asKind(ts.SyntaxKind.Parameter)?.getName();
+                
+            case ts.SyntaxKind.VariableDeclaration:
+                return a.asKind(ts.SyntaxKind.VariableDeclaration)?.getName();
+
+            case ts.SyntaxKind.Decorator:
+                return "@" + a.asKind(ts.SyntaxKind.Decorator)?.getName();    
+
+            case ts.SyntaxKind.TypeParameter:
+                return a.asKind(ts.SyntaxKind.TypeParameter)?.getName();
+
+            case ts.SyntaxKind.EnumDeclaration:
+                return a.asKind(ts.SyntaxKind.EnumDeclaration)?.getName();
+
+            case ts.SyntaxKind.EnumMember:
+                return a.asKind(ts.SyntaxKind.EnumMember)?.getName();
+
+            case ts.SyntaxKind.TypeAliasDeclaration:
+                return a.asKind(ts.SyntaxKind.TypeAliasDeclaration)?.getName();
+
+            case ts.SyntaxKind.Constructor:
+                return "constructor";   
+            
+            default:
+                // ancestor hasn't got a useful name
+                return "";
+        }
+    }
+}

package/src/fqp_implementation.ts

@@ -0,0 +1,66 @@
+import * as ts from "typescript";
+
+function getFullyQualifiedName(
+  node: ts.Node,
+  checker: ts.TypeChecker,
+): string | undefined {
+  // Traverse the lexical hierarchy to construct the fully qualified name.
+  function getQualifiedName(node: ts.Node): string | undefined {
+    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) => {
+    console.log(`statement: ${statement.kind}`);
+    if (ts.isFunctionDeclaration(statement)) {
+        console.log(`function name: ${statement.name?.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.Identifier[] = [];
+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/src/generate_uml.sh

@@ -0,0 +1,16 @@
+# Gets latest plantuml
+rm -f plantuml.jar
+wget --no-verbose https://downloads.sourceforge.net/project/plantuml/plantuml.jar
+# Builds metamodel plantuml from TypeScript sources
+npx tplant -i src/lib/famix/**/*.ts -o doc-metamodel/famix-typescript-model.puml
+sed -i 's/@startuml/& metamodel/' doc-metamodel/famix-typescript-model.puml
+# Converts plantuml source to SVG image
+java -jar plantuml.jar -v -tsvg doc-metamodel/famix-typescript-model.puml
+mv doc-metamodel/metamodel.svg doc-metamodel/metamodel-full.svg
+# Inserts include line to customize the file
+sed -i '/@startuml metamodel/a !include skins.include.puml' doc-metamodel/famix-typescript-model.puml
+# Converts plantuml source to SVG image
+java -jar plantuml.jar -v -tsvg doc-metamodel/famix-typescript-model.puml
+# Moves artifacts
+rm -f doc-uml/*
+mv doc-metamodel/*.svg doc-uml

package/src/lib/famix/License.md

@@ -0,0 +1,23 @@
+Portions of the code in the famix directory:
+
+MIT License
+
+Copyright (c) 2019 Pascal Erni
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.