ts2famix 2.0.0 → 2.0.1

package/src/famix_functions/EntityDictionary.ts

@@ -1,17 +1,21 @@
 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, ImportDeclaration, ImportEqualsDeclaration, SyntaxKind, Expression, TypeNode, Node, ts, Scope, Type, ArrowFunction } from "ts-morph";
 import { isAmbient, isNamespace } from "../analyze_functions/process_functions";
-import * as Famix from "../lib/famix/src/model/famix";
+import * as Famix from "../lib/famix/model/famix";
+import { FamixRepository } from "../lib/famix/famix_repository";
 import { logger, config } from "../analyze";
 import GraphemeSplitter from "grapheme-splitter";
 import * as Helpers from "./helpers_creation";
 import * as FQNFunctions from "../fqn";
-import { FamixRepository } from "../lib/famix/src/famix_repository";
 import path from "path";
 import _ from 'lodash';
 
 export type TSMorphObjectType = ImportDeclaration | ImportEqualsDeclaration | SourceFile | ModuleDeclaration | ClassDeclaration | InterfaceDeclaration | MethodDeclaration | ConstructorDeclaration | MethodSignature | FunctionDeclaration | FunctionExpression | ParameterDeclaration | VariableDeclaration | PropertyDeclaration | PropertySignature | TypeParameterDeclaration | Identifier | Decorator | GetAccessorDeclaration | SetAccessorDeclaration | ImportSpecifier | CommentRange | EnumDeclaration | EnumMember | TypeAliasDeclaration | ExpressionWithTypeArguments;
 
-export type TypeDeclaration = TypeAliasDeclaration | PropertyDeclaration | PropertySignature | MethodDeclaration | ConstructorDeclaration | MethodSignature | GetAccessorDeclaration | SetAccessorDeclaration | FunctionDeclaration | FunctionExpression | ParameterDeclaration | VariableDeclaration | EnumMember;
+export type TypeDeclaration = TypeAliasDeclaration | PropertyDeclaration | PropertySignature | MethodDeclaration | ConstructorDeclaration | MethodSignature | GetAccessorDeclaration | SetAccessorDeclaration | FunctionDeclaration | FunctionExpression | ParameterDeclaration | VariableDeclaration | EnumMember | ImportEqualsDeclaration;
+
+type ParametricVariantType = Famix.ParametricClass | Famix.ParametricInterface | Famix.ParametricFunction | Famix.ParametricMethod;
+
+type ConcreteElementTSMorphType = ClassDeclaration | InterfaceDeclaration | FunctionDeclaration | MethodDeclaration;
 
 export class EntityDictionary {
     
@@ -25,20 +29,86 @@ export class EntityDictionary {
     private fmxFunctionAndMethodMap = new Map<string, Famix.Function | Famix.ParametricFunction | Famix.Method | Famix.ParametricMethod> // Maps the function names to their Famix model
     private UNKNOWN_VALUE = '(unknown due to parsing error)'; // The value to use when a name is not usable
     public fmxElementObjectMap = new Map<Famix.Entity,TSMorphObjectType>();
+    public tsMorphElementObjectMap = new Map<TSMorphObjectType,Famix.Entity>();
             
     constructor() {
         this.famixRep.setFmxElementObjectMap(this.fmxElementObjectMap);      
     }
 
+    public addSourceAnchor(fmx: Famix.SourcedEntity, node: TSMorphObjectType): Famix.IndexedFileAnchor {
+        const sourceAnchor: Famix.IndexedFileAnchor = new Famix.IndexedFileAnchor();
+        let sourceStart, sourceEnd: number;
+        if (fmx && node) {
+            // find the start and end positions of the source element
+            if (!(node instanceof CommentRange)) {
+                sourceStart = node.getStart();
+                sourceEnd = node.getEnd();
+            } else {
+                sourceStart = node.getPos();
+                sourceEnd = node.getEnd();
+            }
+    
+            if (config.expectGraphemes) {
+                /**
+                 * The following logic handles the case of multi-code point characters (e.g. emoji) in the source text.
+                 * This is needed because Pharo/Smalltalk treats multi-code point characters as a single character, 
+                 * but JavaScript treats them as multiple characters. This means that the start and end positions
+                 * of a source element in Pharo/Smalltalk will be different than the start and end positions of the
+                 * same source element in JavaScript. This logic finds the start and end positions of the source
+                 * element in JavaScript and then uses those positions to set the start and end positions of the
+                 * Famix index file anchor.
+                 * It depends on code in the 'grapheme-splitter' package in npm.
+                 */
+                const splitter = new GraphemeSplitter();
+                const sourceFileText = node.getSourceFile().getFullText();
+                const hasGraphemeClusters = splitter.countGraphemes(sourceFileText) > 1;
+                if (hasGraphemeClusters) {
+                    const sourceElementText = sourceFileText.substring(sourceStart, sourceEnd);
+                    const sourceElementTextGraphemes = splitter.splitGraphemes(sourceElementText);
+                    const sourceFileTextGraphemes = splitter.splitGraphemes(sourceFileText);
+                    const numberOfGraphemeClustersBeforeStart = splitter.countGraphemes(sourceFileText.substring(0, sourceStart));
+        
+                    // find the start of the sourceElementTextGraphemes array in the sourceFileTextGraphemes array
+                    sourceStart = Helpers.indexOfSplitArray({searchArray: sourceFileTextGraphemes, 
+                                                        targetArray: sourceElementTextGraphemes, 
+                                                        start: sourceStart - numberOfGraphemeClustersBeforeStart});
+                    sourceEnd = sourceStart + sourceElementTextGraphemes.length;
+                } 
+            }
+
+            // The +1 is because the source anchor (Pharo) is 1-based, but ts-morph is 0-based
+            sourceAnchor.startPos = sourceStart + 1;
+            sourceAnchor.endPos = sourceEnd + 1;
+
+            const fileName = node.getSourceFile().getFilePath();
+
+            sourceAnchor.element = fmx;
+            sourceAnchor.fileName = fileName;
+            fmx.sourceAnchor = sourceAnchor;
+            this.famixRep.addElement(sourceAnchor);
+
+        }
+        return sourceAnchor;
+    }
+
     /**
      * Makes a Famix index file anchor
      * @param sourceElement A source element
      * @param famixElement The Famix model of the source element
      */
     public makeFamixIndexFileAnchor(sourceElement: TSMorphObjectType, famixElement: Famix.SourcedEntity): void {
+        // check if famixElement doesn't have a valid fullyQualifiedName
+        if (typeof (famixElement as any).getFullyQualifiedName === 'function') {
+            // The method exists
+            const fullyQualifiedName = (famixElement as any).fullyQualifiedName;
+            if (!fullyQualifiedName || fullyQualifiedName === this.UNKNOWN_VALUE) {
+                throw new Error(`Famix element ${famixElement.constructor.name} has no valid fullyQualifiedName.`);
+            }
+        }
+
         logger.debug("making index file anchor for '" + sourceElement?.getText() + "' with famixElement " + famixElement.getJSON());
         const fmxIndexFileAnchor = new Famix.IndexedFileAnchor();
-        fmxIndexFileAnchor.setElement(famixElement);
+        fmxIndexFileAnchor.element = famixElement;
         this.fmxElementObjectMap.set(famixElement, sourceElement);
 
         if (sourceElement !== null) {
@@ -60,7 +130,7 @@ export class EntityDictionary {
             // revert any backslashes to forward slashes (path.normalize on windows introduces them)
             pathInProject = pathInProject.replace(/\\/g, "/");
 
-            fmxIndexFileAnchor.setFileName(pathInProject);
+            fmxIndexFileAnchor.fileName = pathInProject;
             let sourceStart, sourceEnd, sourceLineStart, sourceLineEnd: number;
             if (!(sourceElement instanceof CommentRange)) {
                 sourceStart = sourceElement.getStart();
@@ -99,24 +169,18 @@ export class EntityDictionary {
                 } 
             }
             // note: the +1 is because the source anchor is 1-based, but ts-morph is 0-based
-            fmxIndexFileAnchor.setStartPos(sourceStart + 1);
-            fmxIndexFileAnchor.setEndPos(sourceEnd + 1);
-            if (!(sourceElement instanceof CommentRange)) {
-                fmxIndexFileAnchor.setStartLine(sourceLineStart);
-                fmxIndexFileAnchor.setEndLine(sourceLineEnd);    
-            }
+            fmxIndexFileAnchor.startPos = sourceStart + 1;
+            fmxIndexFileAnchor.endPos = sourceEnd + 1;
 
-            if (!(famixElement instanceof Famix.ImportClause || famixElement instanceof Famix.Access || famixElement instanceof Famix.Reference || famixElement instanceof Famix.Invocation || famixElement instanceof Famix.Inheritance) && !(famixElement instanceof Famix.Comment) && !(sourceElement instanceof CommentRange) && !(sourceElement instanceof Identifier) && !(sourceElement instanceof ImportSpecifier) && !(sourceElement instanceof ExpressionWithTypeArguments)) {
-                const fqn = FQNFunctions.getFQN(sourceElement);
-                logger.debug("Setting fully qualified name for " + famixElement.getJSON() + " to " + fqn);
-                (famixElement as Famix.NamedEntity).setFullyQualifiedName(fqn);
-            }
+            // if (!(famixElement instanceof Famix.ImportClause || famixElement instanceof Famix.Access || famixElement instanceof Famix.Reference || famixElement instanceof Famix.Invocation || famixElement instanceof Famix.Inheritance) && !(famixElement instanceof Famix.Comment) && !(sourceElement instanceof CommentRange) && !(sourceElement instanceof Identifier) && !(sourceElement instanceof ImportSpecifier) && !(sourceElement instanceof ExpressionWithTypeArguments)) {
+            //    initFQN(sourceElement, famixElement);
+            // }
         } else {
             // sourceElement is null
             logger.warn("sourceElement is null for famixElement " + famixElement.getJSON());
-            fmxIndexFileAnchor.setFileName("unknown");
-            fmxIndexFileAnchor.setStartPos(0);
-            fmxIndexFileAnchor.setEndPos(0);
+            fmxIndexFileAnchor.fileName = "unknown";
+            fmxIndexFileAnchor.startPos = 0;
+            fmxIndexFileAnchor.endPos = 0;
         }
 
         this.famixRep.addElement(fmxIndexFileAnchor);
@@ -133,16 +197,19 @@ export class EntityDictionary {
 
         const fileName = f.getBaseName();
         const fullyQualifiedFilename = f.getFilePath();
-        if (!this.fmxFileMap.has(fullyQualifiedFilename)) {
+        const foundFileName = this.fmxFileMap.get(fullyQualifiedFilename);
+        if (!foundFileName) {
             if (isModule) {
                 fmxFile = new Famix.Module();
             }
             else {
                 fmxFile = new Famix.ScriptEntity();
             }
-            fmxFile.setName(fileName);
-            fmxFile.setNumberOfLinesOfText(f.getEndLineNumber() - f.getStartLineNumber());
-            fmxFile.setNumberOfCharacters(f.getFullText().length);
+            fmxFile.name = fileName;
+            fmxFile.numberOfLinesOfText = f.getEndLineNumber() - f.getStartLineNumber();
+            fmxFile.numberOfCharacters = f.getFullText().length;
+
+            initFQN(f, fmxFile);
 
             this.makeFamixIndexFileAnchor(f, fmxFile);
 
@@ -150,7 +217,7 @@ export class EntityDictionary {
             this.famixRep.addElement(fmxFile);
         }
         else {
-            fmxFile = this.fmxFileMap.get(fullyQualifiedFilename);
+            fmxFile = foundFileName;
         }
 
         this.fmxElementObjectMap.set(fmxFile,f);
@@ -165,13 +232,15 @@ export class EntityDictionary {
     public createOrGetFamixModule(m: ModuleDeclaration): Famix.Module {
         let fmxModule: Famix.Module;
         const moduleName = m.getName();
-        if (!this.fmxModuleMap.has(moduleName)) {
+        const foundModuleName = this.fmxModuleMap.get(moduleName);
+        if (!foundModuleName) {
             fmxModule = new Famix.Module();
-            fmxModule.setName(moduleName);
-            fmxModule.$isAmbient = isAmbient(m);
-            fmxModule.$isNamespace = isNamespace(m);
-            fmxModule.$isModule = !fmxModule.$isNamespace && !fmxModule.$isAmbient;
+            fmxModule.name = moduleName;
+            fmxModule.isAmbient = isAmbient(m);
+            fmxModule.isNamespace = isNamespace(m);
+            fmxModule.isModule = !fmxModule.isNamespace && !fmxModule.isAmbient;
 
+            initFQN(m, fmxModule);
             this.makeFamixIndexFileAnchor(m, fmxModule);
 
             this.fmxModuleMap.set(moduleName, fmxModule);
@@ -179,7 +248,7 @@ export class EntityDictionary {
             this.famixRep.addElement(fmxModule);
         }
         else {
-            fmxModule = this.fmxModuleMap.get(moduleName);
+            fmxModule = foundModuleName;
         }
 
         this.fmxElementObjectMap.set(fmxModule,m);
@@ -195,15 +264,16 @@ export class EntityDictionary {
         let fmxAlias: Famix.Alias;
         const aliasName = a.getName();
         const aliasFullyQualifiedName = a.getType().getText(); // FQNFunctions.getFQN(a);
-        if (!this.fmxAliasMap.has(aliasFullyQualifiedName)) {
+        const foundAlias = this.fmxAliasMap.get(aliasFullyQualifiedName);
+        if (!foundAlias) {
             fmxAlias = new Famix.Alias();
-            fmxAlias.setName(a.getName());
+            fmxAlias.name = a.getName();
             const aliasNameWithGenerics = aliasName + (a.getTypeParameters().length ? ("<" + a.getTypeParameters().map(tp => tp.getName()).join(", ") + ">") : "");
             logger.debug(`> NOTE: alias ${aliasName} has fully qualified name ${aliasFullyQualifiedName} and name with generics ${aliasNameWithGenerics}.`);
 
             const fmxType = this.createOrGetFamixType(aliasNameWithGenerics, a);
-            fmxAlias.setAliasedEntity(fmxType);
-
+            fmxAlias.aliasedEntity = fmxType;
+            initFQN(a, fmxAlias);
             this.makeFamixIndexFileAnchor(a, fmxAlias);
 
             this.fmxAliasMap.set(aliasFullyQualifiedName, fmxAlias);
@@ -211,7 +281,7 @@ export class EntityDictionary {
             this.famixRep.addElement(fmxAlias);
         }
         else {
-            fmxAlias = this.fmxAliasMap.get(aliasFullyQualifiedName);
+            fmxAlias = foundAlias;
         }
         this.fmxElementObjectMap.set(fmxAlias,a);
 
@@ -227,9 +297,10 @@ export class EntityDictionary {
         let fmxClass: Famix.Class | Famix.ParametricClass;
         const isAbstract = cls.isAbstract();
         const classFullyQualifiedName = FQNFunctions.getFQN(cls);
-        const clsName = cls.getName();
+        const clsName = cls.getName() || this.UNKNOWN_VALUE;
         const isGeneric = cls.getTypeParameters().length;
-        if (!this.fmxClassMap.has(classFullyQualifiedName)) {
+        const foundClass = this.fmxClassMap.get(classFullyQualifiedName);
+        if (!foundClass) {
             if (isGeneric) {
                 fmxClass = new Famix.ParametricClass();
             }
@@ -237,9 +308,9 @@ export class EntityDictionary {
                 fmxClass = new Famix.Class();
             }
 
-            fmxClass.setName(clsName);
-            fmxClass.setFullyQualifiedName(classFullyQualifiedName);
-            fmxClass.setIsAbstract(isAbstract);
+            fmxClass.name = clsName;
+            fmxClass.fullyQualifiedName = classFullyQualifiedName;
+            fmxClass.isAbstract = isAbstract;
 
             this.makeFamixIndexFileAnchor(cls, fmxClass);
 
@@ -250,7 +321,7 @@ export class EntityDictionary {
             this.fmxElementObjectMap.set(fmxClass,cls);
         }
         else {
-            fmxClass = this.fmxClassMap.get(classFullyQualifiedName) as (Famix.Class | Famix.ParametricClass);
+            fmxClass = foundClass;
         }
 
         return fmxClass;
@@ -262,10 +333,12 @@ export class EntityDictionary {
      * @returns The Famix model of the interface
      */
     public createOrGetFamixInterface(inter: InterfaceDeclaration): Famix.Interface | Famix.ParametricInterface {
+
         let fmxInterface: Famix.Interface | Famix.ParametricInterface;
         const interName = inter.getName();
         const interFullyQualifiedName = FQNFunctions.getFQN(inter);
-        if (!this.fmxInterfaceMap.has(interFullyQualifiedName)) {
+        const foundInterface = this.fmxInterfaceMap.get(interFullyQualifiedName);
+        if (!foundInterface) {
             const isGeneric = inter.getTypeParameters().length;
             if (isGeneric) {
                 fmxInterface = new Famix.ParametricInterface();
@@ -274,8 +347,8 @@ export class EntityDictionary {
                 fmxInterface = new Famix.Interface();
             }
 
-            fmxInterface.setName(interName);
-
+            fmxInterface.name = interName;
+            initFQN(inter, fmxInterface);
             this.makeFamixIndexFileAnchor(inter, fmxInterface);
 
             this.fmxInterfaceMap.set(interFullyQualifiedName, fmxInterface);
@@ -285,21 +358,24 @@ export class EntityDictionary {
             this.fmxElementObjectMap.set(fmxInterface,inter);
         }
         else {
-            fmxInterface = this.fmxInterfaceMap.get(interFullyQualifiedName) as (Famix.Interface | Famix.ParametricInterface);
+            fmxInterface = foundInterface;
         }
         return fmxInterface;
     }
 
+    
     /**
      * Creates or gets a Famix concrete element
-     * @param el A parametric Element   
-     * @param elDeclaration the element declaration
+     * @param concreteElement A parametric Element   
+     * @param concreteElementDeclaration the element declaration
      * @param concreteArguments concrete arguments
      * @returns A parametric Element  
      */
-    public createOrGetFamixConcreteElement(el : Famix.ParametricClass | Famix.ParametricInterface | Famix.ParametricFunction | Famix.ParametricMethod, elDeclaration : ClassDeclaration | InterfaceDeclaration | FunctionDeclaration | MethodDeclaration, concreteArguments : any): Famix.ParametricClass | Famix.ParametricInterface | Famix.ParametricFunction | Famix.ParametricMethod {
+    public createOrGetFamixConcreteElement(concreteElement : ParametricVariantType, 
+                                           concreteElementDeclaration : ConcreteElementTSMorphType, 
+                                           concreteArguments: TypeNode[]): ParametricVariantType {
         
-        let fullyQualifiedFilename = el.getFullyQualifiedName();
+        let fullyQualifiedFilename = concreteElement.fullyQualifiedName;
         let params = "";
         
         concreteArguments.map((param) => {
@@ -310,37 +386,39 @@ export class EntityDictionary {
                 
         fullyQualifiedFilename = Helpers.replaceLastBetweenTags(fullyQualifiedFilename,params);
 
-        let concElement;
+        let concElement: ParametricVariantType;
 
-        if (!this.fmxInterfaceMap.has(fullyQualifiedFilename) && !this.fmxClassMap.has(fullyQualifiedFilename) && !this.fmxFunctionAndMethodMap.has(fullyQualifiedFilename)){
-            concElement = _.cloneDeep(el); 
-            concElement.setFullyQualifiedName(fullyQualifiedFilename);
+        if (!this.fmxInterfaceMap.has(fullyQualifiedFilename) && 
+            !this.fmxClassMap.has(fullyQualifiedFilename) && 
+            !this.fmxFunctionAndMethodMap.has(fullyQualifiedFilename)){
+            concElement = _.cloneDeep(concreteElement); 
+            concElement.fullyQualifiedName = fullyQualifiedFilename;
             concElement.clearGenericParameters();
             concreteArguments.map((param) => {
                 const parameter = this.createOrGetFamixConcreteType(param);
                 concElement.addConcreteParameter(parameter);
             })
             
-            if (el instanceof Famix.ParametricClass) {
+            if (concreteElement instanceof Famix.ParametricClass) {
                 this.fmxClassMap.set(fullyQualifiedFilename, concElement as Famix.ParametricClass);
-            } else if (el instanceof Famix.ParametricInterface) {
+            } else if (concreteElement instanceof Famix.ParametricInterface) {
                 this.fmxInterfaceMap.set(fullyQualifiedFilename, concElement as Famix.ParametricInterface);
-            } else if (el instanceof Famix.ParametricFunction) {
+            } else if (concreteElement instanceof Famix.ParametricFunction) {
                 this.fmxFunctionAndMethodMap.set(fullyQualifiedFilename, concElement as Famix.ParametricFunction);
-            } else if (el instanceof Famix.ParametricMethod) {
+            } else { // if (concreteElement instanceof Famix.ParametricMethod) {
                 this.fmxFunctionAndMethodMap.set(fullyQualifiedFilename, concElement as Famix.ParametricMethod);
             }
             this.famixRep.addElement(concElement);
-            this.fmxElementObjectMap.set(concElement,elDeclaration);
+            this.fmxElementObjectMap.set(concElement,concreteElementDeclaration);
         } else {
-            if (el instanceof Famix.ParametricClass) {
-                concElement = this.fmxClassMap.get(fullyQualifiedFilename);
-            } else if (el instanceof Famix.ParametricInterface) {
-                concElement = this.fmxInterfaceMap.get(fullyQualifiedFilename);
-            } else if (el instanceof Famix.ParametricFunction) {
-                concElement = this.fmxFunctionAndMethodMap.get(fullyQualifiedFilename);
-            } else if (el instanceof Famix.ParametricMethod) {
-                concElement = this.fmxFunctionAndMethodMap.get(fullyQualifiedFilename);
+            if (concreteElement instanceof Famix.ParametricClass) {
+                concElement = this.fmxClassMap.get(fullyQualifiedFilename) as Famix.ParametricClass;
+            } else if (concreteElement instanceof Famix.ParametricInterface) {
+                concElement = this.fmxInterfaceMap.get(fullyQualifiedFilename) as Famix.ParametricInterface;
+            } else if (concreteElement instanceof Famix.ParametricFunction) {
+                concElement = this.fmxFunctionAndMethodMap.get(fullyQualifiedFilename) as Famix.ParametricFunction;
+            } else {  // if (concreteElement instanceof Famix.ParametricMethod) {
+                concElement = this.fmxFunctionAndMethodMap.get(fullyQualifiedFilename) as Famix.ParametricMethod;
             }
         }
         return concElement;
@@ -354,7 +432,7 @@ export class EntityDictionary {
     public createFamixProperty(property: PropertyDeclaration | PropertySignature): Famix.Property {
         const fmxProperty = new Famix.Property();
         const isSignature = property instanceof PropertySignature;
-        fmxProperty.setName(property.getName());
+        fmxProperty.name = property.getName();
 
         let propTypeName = this.UNKNOWN_VALUE;
         try {
@@ -364,7 +442,7 @@ export class EntityDictionary {
         }
 
         const fmxType = this.createOrGetFamixType(propTypeName, property);
-        fmxProperty.setDeclaredType(fmxType);
+        fmxProperty.declaredType = fmxType;
 
         // add the visibility (public, private, etc.) to the fmxProperty
         fmxProperty.visibility = "";
@@ -381,7 +459,7 @@ export class EntityDictionary {
                     fmxProperty.visibility = "private";
                     break;
                 case "static":
-                    fmxProperty.setIsClassSide(true);
+                    fmxProperty.isClassSide = true;
                     break;
                 case "readonly":
                     fmxProperty.readOnly = true;
@@ -401,6 +479,7 @@ export class EntityDictionary {
             fmxProperty.isJavaScriptPrivate = true;
         }
 
+        initFQN(property, fmxProperty);
         this.makeFamixIndexFileAnchor(property, fmxProperty);
 
         this.famixRep.addElement(fmxProperty);
@@ -416,7 +495,7 @@ export class EntityDictionary {
      * @param currentCC The cyclomatic complexity metrics of the current source file
      * @returns The Famix model of the method or the accessor
      */
-    public createOrGetFamixMethod(method: MethodDeclaration | ConstructorDeclaration | MethodSignature | GetAccessorDeclaration | SetAccessorDeclaration, currentCC: unknown): Famix.Method | Famix.Accessor | Famix.ParametricMethod {
+    public createOrGetFamixMethod(method: MethodDeclaration | ConstructorDeclaration | MethodSignature | GetAccessorDeclaration | SetAccessorDeclaration, currentCC: { [key: string]: number }): Famix.Method | Famix.Accessor | Famix.ParametricMethod {
         let fmxMethod: Famix.Method | Famix.Accessor | Famix.ParametricMethod;
         const isGeneric = method.getTypeParameters().length > 0;
         const functionFullyQualifiedName = FQNFunctions.getFQN(method);
@@ -426,8 +505,8 @@ export class EntityDictionary {
                 fmxMethod = new Famix.Accessor();
                 const isGetter = method instanceof GetAccessorDeclaration;
                 const isSetter = method instanceof SetAccessorDeclaration;
-                if (isGetter) {(fmxMethod as Famix.Accessor).setKind("getter");}
-                if (isSetter) {(fmxMethod as Famix.Accessor).setKind("setter");}
+                if (isGetter) {(fmxMethod as Famix.Accessor).kind = "getter";}
+                if (isSetter) {(fmxMethod as Famix.Accessor).kind = "setter";}
                 this.famixRep.addElement(fmxMethod);
             }
             else {
@@ -449,12 +528,12 @@ export class EntityDictionary {
                 isStatic = method.isStatic();
             }
 
-            if (isConstructor) {(fmxMethod as Famix.Accessor).setKind("constructor");}
-            fmxMethod.setIsAbstract(isAbstract);
-            fmxMethod.setIsClassSide(isStatic);
-            fmxMethod.setIsPrivate((method instanceof MethodDeclaration || method instanceof GetAccessorDeclaration || method instanceof SetAccessorDeclaration) ? (method.getModifiers().find(x => x.getText() === 'private')) !== undefined : false);
-            fmxMethod.setIsProtected((method instanceof MethodDeclaration || method instanceof GetAccessorDeclaration || method instanceof SetAccessorDeclaration) ? (method.getModifiers().find(x => x.getText() === 'protected')) !== undefined : false);
-            fmxMethod.setSignature(Helpers.computeSignature(method.getText()));
+            if (isConstructor) {(fmxMethod as Famix.Accessor).kind = "constructor";}
+            fmxMethod.isAbstract = isAbstract;
+            fmxMethod.isClassSide = isStatic;
+            fmxMethod.isPrivate = (method instanceof MethodDeclaration || method instanceof GetAccessorDeclaration || method instanceof SetAccessorDeclaration) ? (method.getModifiers().find(x => x.getText() === 'private')) !== undefined : false;
+            fmxMethod.isProtected = (method instanceof MethodDeclaration || method instanceof GetAccessorDeclaration || method instanceof SetAccessorDeclaration) ? (method.getModifiers().find(x => x.getText() === 'protected')) !== undefined : false;
+            fmxMethod.signature = Helpers.computeSignature(method.getText());
 
             let methodName: string;
             if (isConstructor) {
@@ -463,48 +542,49 @@ export class EntityDictionary {
             else {
                 methodName = (method as MethodDeclaration | MethodSignature | GetAccessorDeclaration | SetAccessorDeclaration).getName();
             }
-            fmxMethod.setName(methodName);
+            fmxMethod.name = methodName;
 
             if (!isConstructor) {
                 if (method.getName().substring(0, 1) === "#") {
-                    fmxMethod.setIsPrivate(true);
+                    fmxMethod.isPrivate = true;
                 }
             }
 
-            if (!fmxMethod.getIsPrivate() && !fmxMethod.getIsProtected()) {
-                fmxMethod.setIsPublic(true);    
+            if (!fmxMethod.isPrivate && !fmxMethod.isProtected) {
+                fmxMethod.isPublic = true;
             }
             else {
-                fmxMethod.setIsPublic(false);
+                fmxMethod.isPublic = false;
             }
 
             if (!isSignature) {
-                fmxMethod.setCyclomaticComplexity(currentCC[fmxMethod.getName()]);
+                fmxMethod.cyclomaticComplexity = currentCC[fmxMethod.name];
             }
             else {
-                fmxMethod.setCyclomaticComplexity(0);
+                fmxMethod.cyclomaticComplexity = 0;
             }
 
             let methodTypeName = this.UNKNOWN_VALUE; 
             try {
                 methodTypeName = method.getReturnType().getText().trim();            
             } catch (error) {
-                logger.error(`> WARNING: got exception ${error}. Failed to get usable name for return type of method: ${fmxMethod.getName()}. Continuing...`);
+                logger.error(`> WARNING: got exception ${error}. Failed to get usable name for return type of method: ${fmxMethod.name}. Continuing...`);
             }
 
             const fmxType = this.createOrGetFamixType(methodTypeName, method);
-            fmxMethod.setDeclaredType(fmxType);
-            fmxMethod.setNumberOfLinesOfCode(method.getEndLineNumber() - method.getStartLineNumber());
+            fmxMethod.declaredType = fmxType;
+            fmxMethod.numberOfLinesOfCode = method.getEndLineNumber() - method.getStartLineNumber();
             const parameters = method.getParameters();
-            fmxMethod.setNumberOfParameters(parameters.length);
+            fmxMethod.numberOfParameters = parameters.length;
 
             if (!isSignature) {
-                fmxMethod.setNumberOfStatements(method.getStatements().length);
+                fmxMethod.numberOfStatements = method.getStatements().length;
             }
             else {
-                fmxMethod.setNumberOfStatements(0);
+                fmxMethod.numberOfStatements = 0;
             }
             
+            initFQN(method, fmxMethod);
             this.makeFamixIndexFileAnchor(method, fmxMethod);
 
             this.fmxFunctionAndMethodMap.set(functionFullyQualifiedName, fmxMethod);
@@ -524,7 +604,7 @@ export class EntityDictionary {
      * @param currentCC The cyclomatic complexity metrics of the current source file
      * @returns The Famix model of the function
      */
-    public createOrGetFamixFunction(func: FunctionDeclaration | FunctionExpression, currentCC: unknown): Famix.Function | Famix.ParametricFunction {
+    public createOrGetFamixFunction(func: FunctionDeclaration | FunctionExpression, currentCC: { [key: string]: number }): Famix.Function | Famix.ParametricFunction {
         let fmxFunction: Famix.Function | Famix.ParametricFunction;
         const isGeneric = func.getTypeParameters().length > 0;        
         const functionFullyQualifiedName = FQNFunctions.getFQN(func);
@@ -536,16 +616,17 @@ export class EntityDictionary {
                 fmxFunction = new Famix.Function();
             }
     
-            if (func.getName()) {
-                fmxFunction.setName(func.getName());
+            const name = func.getName();
+            if (name) {
+                fmxFunction.name = name;
             }
             else {
-                fmxFunction.setName("anonymous");
+                fmxFunction.name = "anonymous";
             }
 
-            fmxFunction.setSignature(Helpers.computeSignature(func.getText()));
-            fmxFunction.setCyclomaticComplexity(currentCC[fmxFunction.getName()]);
-            fmxFunction.setFullyQualifiedName(functionFullyQualifiedName);
+            fmxFunction.signature = Helpers.computeSignature(func.getText());
+            fmxFunction.cyclomaticComplexity = currentCC[fmxFunction.name];
+            fmxFunction.fullyQualifiedName = functionFullyQualifiedName;
     
             let functionTypeName = this.UNKNOWN_VALUE;
             try {
@@ -555,12 +636,11 @@ export class EntityDictionary {
             }
     
             const fmxType = this.createOrGetFamixType(functionTypeName, func);
-            fmxFunction.setDeclaredType(fmxType);
-            fmxFunction.setNumberOfLinesOfCode(func.getEndLineNumber() - func.getStartLineNumber());
+            fmxFunction.declaredType = fmxType;
+            fmxFunction.numberOfLinesOfCode = func.getEndLineNumber() - func.getStartLineNumber();
             const parameters = func.getParameters();
-            fmxFunction.setNumberOfParameters(parameters.length);
-            fmxFunction.setNumberOfStatements(func.getStatements().length);
-    
+            fmxFunction.numberOfParameters = parameters.length;
+            fmxFunction.numberOfStatements = func.getStatements().length;
             this.makeFamixIndexFileAnchor(func, fmxFunction);
     
             this.famixRep.addElement(fmxFunction);
@@ -592,9 +672,10 @@ export class EntityDictionary {
         }
 
         const fmxType = this.createOrGetFamixType(paramTypeName, param);
-        fmxParam.setDeclaredType(fmxType);
-        fmxParam.setName(param.getName());
+        fmxParam.declaredType = fmxType;
+        fmxParam.name = param.getName();
 
+        initFQN(param, fmxParam);
         this.makeFamixIndexFileAnchor(param, fmxParam);
 
         this.famixRep.addElement(fmxParam);
@@ -613,8 +694,8 @@ export class EntityDictionary {
         
         const fmxParameterType = new Famix.ParameterType();
    
-        fmxParameterType.setName(tp.getName());      
-
+        fmxParameterType.name = tp.getName();      
+        initFQN(tp, fmxParameterType);
         this.makeFamixIndexFileAnchor(tp, fmxParameterType);
 
         this.famixRep.addElement(fmxParameterType);
@@ -632,13 +713,13 @@ export class EntityDictionary {
     public createOrGetFamixConcreteType(param: TypeNode): Famix.ParameterType | Famix.PrimitiveType | Famix.Class | Famix.Interface {
         const typeParameterDeclaration = param.getSymbol()?.getDeclarations()[0] as TypeParameterDeclaration;
         const parameterTypeName : string = param.getText();
-        let fmxParameterType: Famix.Type | Famix.Class | Famix.Interface;
+        let fmxParameterType: Famix.Type | Famix.Class | Famix.Interface | undefined = undefined;
 
         let isClassOrInterface = false;
         if (this.fmxClassMap.has(parameterTypeName)){
             this.fmxClassMap.forEach((obj, name) => {
                 if(obj instanceof Famix.ParametricClass){
-                    if (name === param.getText() && obj.getGenericParameters().size>0) {
+                    if (name === param.getText() && obj.genericParameters.size>0) {
                         fmxParameterType = obj;
                         isClassOrInterface = true;
                     } 
@@ -654,7 +735,7 @@ export class EntityDictionary {
         if (this.fmxInterfaceMap.has(parameterTypeName)){
             this.fmxInterfaceMap.forEach((obj, name) => {
                 if(obj instanceof Famix.ParametricInterface){
-                    if (name === param.getText() && obj.getGenericParameters().size>0) {
+                    if (name === param.getText() && obj.genericParameters.size>0) {
                         fmxParameterType = obj;
                         isClassOrInterface = true;
                     } 
@@ -671,21 +752,28 @@ export class EntityDictionary {
             if (!this.fmxTypeMap.has(parameterTypeName)) {           
                 if (parameterTypeName === "number" || parameterTypeName === "string" || parameterTypeName === "boolean" || parameterTypeName === "bigint" || parameterTypeName === "symbol" || parameterTypeName === "undefined" || parameterTypeName === "null" || parameterTypeName === "any" || parameterTypeName === "unknown" || parameterTypeName === "never" || parameterTypeName === "void") {
                     fmxParameterType = new Famix.PrimitiveType();
-                    fmxParameterType.setIsStub(true);
+                    fmxParameterType.isStub = true;
                 } else {
                     fmxParameterType = new Famix.ParameterType();
                 } 
     
-                fmxParameterType.setName(parameterTypeName);
+                fmxParameterType.name = parameterTypeName;
                 this.famixRep.addElement(fmxParameterType);
                 this.fmxTypeMap.set(parameterTypeName, fmxParameterType);
                 this.fmxElementObjectMap.set(fmxParameterType,typeParameterDeclaration);
             }
             else {
-                fmxParameterType = this.fmxTypeMap.get(parameterTypeName);
+                const result = this.fmxTypeMap.get(parameterTypeName);
+                if (result) {
+                    fmxParameterType = result;
+                } else {
+                    throw new Error(`Famix type ${parameterTypeName} is not found in the Type map.`);
+                }
             }
         }
-
+        if (!fmxParameterType) {
+            throw new Error(`fmxParameterType was undefined for parameterTypeName ${parameterTypeName}`);
+        }
         return fmxParameterType;
     }
 
@@ -705,9 +793,9 @@ export class EntityDictionary {
         }
     
         const fmxType = this.createOrGetFamixType(variableTypeName, variable);
-        fmxVariable.setDeclaredType(fmxType);
-        fmxVariable.setName(variable.getName());
-    
+        fmxVariable.declaredType = fmxType;
+        fmxVariable.name = variable.getName();
+        initFQN(variable, fmxVariable);
         this.makeFamixIndexFileAnchor(variable, fmxVariable);
     
         this.famixRep.addElement(fmxVariable);
@@ -724,8 +812,8 @@ export class EntityDictionary {
      */
     public createFamixEnum(enumEntity: EnumDeclaration): Famix.Enum {
         const fmxEnum = new Famix.Enum();
-        fmxEnum.setName(enumEntity.getName());
-
+        fmxEnum.name = enumEntity.getName();
+        initFQN(enumEntity, fmxEnum);
         this.makeFamixIndexFileAnchor(enumEntity, fmxEnum);
 
         this.famixRep.addElement(fmxEnum);
@@ -751,9 +839,9 @@ export class EntityDictionary {
         }
 
         const fmxType = this.createOrGetFamixType(enumValueTypeName, enumMember);
-        fmxEnumValue.setDeclaredType(fmxType);
-        fmxEnumValue.setName(enumMember.getName());
-
+        fmxEnumValue.declaredType = fmxType;
+        fmxEnumValue.name = enumMember.getName();
+        initFQN(enumMember, fmxEnumValue);
         this.makeFamixIndexFileAnchor(enumMember, fmxEnumValue);
 
         this.famixRep.addElement(fmxEnumValue);
@@ -774,12 +862,12 @@ export class EntityDictionary {
         const decoratorName = "@" + decorator.getName();
         const decoratorExpression = decorator.getText().substring(1);
 
-        fmxDecorator.setName(decoratorName);
-        fmxDecorator.setDecoratorExpression(decoratorExpression);
+        fmxDecorator.name = decoratorName;
+        fmxDecorator.decoratorExpression = decoratorExpression;
         const decoratedEntityFullyQualifiedName = FQNFunctions.getFQN(decoratedEntity);
         const fmxDecoratedEntity = this.famixRep.getFamixEntityByFullyQualifiedName(decoratedEntityFullyQualifiedName) as Famix.NamedEntity;
-        fmxDecorator.setDecoratedEntity(fmxDecoratedEntity);
-
+        fmxDecorator.decoratedEntity = fmxDecoratedEntity;
+        initFQN(decorator, fmxDecorator);
         this.makeFamixIndexFileAnchor(decorator, fmxDecorator);
 
         this.famixRep.addElement(fmxDecorator);
@@ -797,10 +885,10 @@ export class EntityDictionary {
      * @returns The Famix model of the comment
      */
     public createFamixComment(comment: CommentRange, fmxScope: Famix.NamedEntity, isJSDoc: boolean): Famix.Comment {
-        logger.debug(`> NOTE: creating comment ${comment.getText()} in scope ${fmxScope.getName()}.`);
+        logger.debug(`> NOTE: creating comment ${comment.getText()} in scope ${fmxScope.name}.`);
         const fmxComment = new Famix.Comment();
-        fmxComment.setContainer(fmxScope);  // adds comment to the container's comments collection
-        fmxComment.setIsJSDoc(isJSDoc);
+        fmxComment.container = fmxScope;  // adds comment to the container's comments collection
+        fmxComment.isJSDoc = isJSDoc;
 
         this.makeFamixIndexFileAnchor(comment, fmxComment);
 
@@ -823,7 +911,7 @@ export class EntityDictionary {
         let isParameterType = false;
 
         logger.debug("Creating (or getting) type: '" + typeName + "' of element: " + element?.getText() + " of kind: " + element?.getKindName());
-        let ancestor: Famix.ContainerEntity;
+        let ancestor: Famix.ContainerEntity | undefined = undefined;
         if (element !== undefined) {
             const typeAncestor = Helpers.findTypeAncestor(element);
             if (!typeAncestor) {
@@ -848,7 +936,7 @@ export class EntityDictionary {
         if (!this.fmxTypeMap.has(typeName)) {
             if (isPrimitiveType) {
                 fmxType = new Famix.PrimitiveType();
-                fmxType.setIsStub(true);
+                fmxType.isStub = true;
             }
             else if (isParameterType) {
                 fmxType = new Famix.ParameterType();
@@ -859,15 +947,18 @@ export class EntityDictionary {
                     (fmxType as Famix.ParameterType).addArgument(fmxParameterType);
                 });
                 const fmxBaseType = this.createOrGetFamixType(baseTypeName, element);
-                (fmxType as Famix.ParameterType).setBaseType(fmxBaseType);
+                (fmxType as Famix.ParameterType).baseType = fmxBaseType;
             }
             else {
                 fmxType = new Famix.Type();
             }
 
-            fmxType.setName(typeName);
-            fmxType.setContainer(ancestor);
-            
+            fmxType.name = typeName;
+            if (!ancestor) {
+                throw new Error(`Ancestor not found for type ${typeName}.`);
+            }
+            fmxType.container = ancestor;
+            initFQN(element, fmxType);
             this.makeFamixIndexFileAnchor(element, fmxType);
 
             this.famixRep.addElement(fmxType);
@@ -875,7 +966,12 @@ export class EntityDictionary {
             this.fmxTypeMap.set(typeName, fmxType);
         }
         else {
-            fmxType = this.fmxTypeMap.get(typeName);
+            const result = this.fmxTypeMap.get(typeName);
+            if (result) {
+                fmxType = result;
+            } else {
+                throw new Error(`Famix type ${typeName} is not found in the Type map.`);
+            }
         }
 
         this.fmxElementObjectMap.set(fmxType,element);
@@ -894,7 +990,7 @@ export class EntityDictionary {
             throw new Error(`Famix entity with id ${id} not found, for node ${node.getText()} in ${node.getSourceFile().getBaseName()} at line ${node.getStartLineNumber()}.`);
         }
 
-        logger.debug(`Creating FamixAccess. Node: [${node.getKindName()}] '${node.getText()}' at line ${node.getStartLineNumber()} in ${node.getSourceFile().getBaseName()}, id: ${id} refers to fmxVar '${fmxVar.getFullyQualifiedName()}'.`);
+        logger.debug(`Creating FamixAccess. Node: [${node.getKindName()}] '${node.getText()}' at line ${node.getStartLineNumber()} in ${node.getSourceFile().getBaseName()}, id: ${id} refers to fmxVar '${fmxVar.fullyQualifiedName}'.`);
 
         const nodeReferenceAncestor = Helpers.findAncestor(node);
         const ancestorFullyQualifiedName = FQNFunctions.getFQN(nodeReferenceAncestor);
@@ -905,8 +1001,8 @@ export class EntityDictionary {
         }
 
         const fmxAccess = new Famix.Access();
-        fmxAccess.setAccessor(accessor);
-        fmxAccess.setVariable(fmxVar);
+        fmxAccess.accessor = accessor;
+        fmxAccess.variable = fmxVar;
 
         this.famixRep.addElement(fmxAccess);
 
@@ -928,10 +1024,10 @@ export class EntityDictionary {
         const receiver = this.famixRep.getFamixEntityByFullyQualifiedName(receiverFullyQualifiedName) as Famix.NamedEntity;
 
         const fmxInvocation = new Famix.Invocation();
-        fmxInvocation.setSender(sender);
-        fmxInvocation.setReceiver(receiver);
+        fmxInvocation.sender = sender;
+        fmxInvocation.receiver = receiver;
         fmxInvocation.addCandidate(fmxMethodOrFunction);
-        fmxInvocation.setSignature(fmxMethodOrFunction.getSignature());
+        fmxInvocation.signature = fmxMethodOrFunction.signature;
 
         this.famixRep.addElement(fmxInvocation);
 
@@ -948,19 +1044,25 @@ export class EntityDictionary {
         // const clsName = cls.getName();
         const classFullyQualifiedName = FQNFunctions.getFQN(cls);
         logger.debug(`createFamixInheritance: classFullyQualifiedName: class fqn = ${classFullyQualifiedName}`);
-        let subClass: Famix.Class | Famix.Interface;
+        let subClass: Famix.Class | Famix.Interface | undefined;
         if (cls instanceof ClassDeclaration) {
             subClass = this.fmxClassMap.get(classFullyQualifiedName);
         }
         else {
             subClass = this.fmxInterfaceMap.get(classFullyQualifiedName);
         }
+        if (!subClass) {
+            throw new Error(`Subclass ${classFullyQualifiedName} not found in Class or Interface maps.`);
+        }
         
-        let inhClassName: string;
+        let inhClassName: string | undefined;
         let inhClassFullyQualifiedName: string;
-        let superClass: Famix.Class | Famix.Interface;
+        let superClass: Famix.Class | Famix.Interface | undefined;
         if (inhClass instanceof ClassDeclaration || inhClass instanceof InterfaceDeclaration) {
             inhClassName = inhClass.getName();
+            if (!inhClassName) {
+                throw new Error(`Inherited class or interface name not found for ${inhClass.getText()}.`);
+            }
             inhClassFullyQualifiedName = FQNFunctions.getFQN(inhClass);
             if (inhClass instanceof ClassDeclaration) {
                 superClass = this.fmxClassMap.get(inhClassFullyQualifiedName);
@@ -968,6 +1070,9 @@ export class EntityDictionary {
             else {
                 superClass = this.fmxInterfaceMap.get(inhClassFullyQualifiedName);
             }
+            if (!superClass) {
+                throw new Error(`Superclass ${classFullyQualifiedName} not found in Class or Interface maps.`);
+            }
         }
         else {
             // inhClass is an ExpressionWithTypeArguments
@@ -988,28 +1093,29 @@ export class EntityDictionary {
 
             this.fmxElementObjectMap.set(superClass,inhClass);
 
-            superClass.setName(inhClassName);
-            superClass.setFullyQualifiedName(inhClassFullyQualifiedName);
-            superClass.setIsStub(true);
+            superClass.name = inhClassName;
+            superClass.fullyQualifiedName = inhClassFullyQualifiedName;
+            superClass.isStub = true;
 
             this.makeFamixIndexFileAnchor(inhClass, superClass);
         
             this.famixRep.addElement(superClass);
         }
 
-        fmxInheritance.setSubclass(subClass);
-        fmxInheritance.setSuperclass(superClass);
+        fmxInheritance.subclass = subClass;
+        fmxInheritance.superclass = superClass;
 
         this.famixRep.addElement(fmxInheritance);
 
-        this.fmxElementObjectMap.set(fmxInheritance,null);
+        // We don't map inheritance to the source code element because there are two elements (super, sub)
+        // this.fmxElementObjectMap.set(fmxInheritance, null);
 
     }
 
     public createFamixImportClause(importedEntity: Famix.NamedEntity, importingEntity: Famix.Module) {
         const fmxImportClause = new Famix.ImportClause();
-        fmxImportClause.setImportedEntity(importedEntity);
-        fmxImportClause.setImportingEntity(importingEntity);
+        fmxImportClause.importedEntity = importedEntity;
+        fmxImportClause.importingEntity = importingEntity;
         importingEntity.addOutgoingImport(fmxImportClause);
         this.famixRep.addElement(fmxImportClause);
     }
@@ -1029,7 +1135,7 @@ export class EntityDictionary {
         logger.debug(`createFamixImportClause: Creating import clause:`);
         const fmxImportClause = new Famix.ImportClause();
 
-        let importedEntity: Famix.NamedEntity | Famix.StructuralEntity;
+        let importedEntity: Famix.NamedEntity | Famix.StructuralEntity | undefined = undefined;
         let importedEntityName: string;
 
         const absolutePathProject = this.famixRep.getAbsolutePath();
@@ -1052,12 +1158,12 @@ export class EntityDictionary {
             }
             if (importedEntity === undefined) {
                 importedEntity = new Famix.NamedEntity();
-                importedEntity.setName(importedEntityName);
+                importedEntity.name = importedEntityName;
                 if (!isInExports) {
-                    importedEntity.setIsStub(true);
+                    importedEntity.isStub = true;
                 }
+                importedEntity.fullyQualifiedName = pathName;
                 this.makeFamixIndexFileAnchor(importElement, importedEntity);
-                importedEntity.setFullyQualifiedName(pathName);
                 // must add entity to repository
                 this.famixRep.addElement(importedEntity);
             }
@@ -1068,39 +1174,40 @@ export class EntityDictionary {
             importedEntityName = importDeclaration?.getName();
             pathName = pathName + importedEntityName;
             importedEntity = new Famix.StructuralEntity();
-            importedEntity.setName(importedEntityName);
+            importedEntity.name = importedEntityName;
+            initFQN(importDeclaration, importedEntity);
             this.makeFamixIndexFileAnchor(importElement, importedEntity);
-            importedEntity.setFullyQualifiedName(pathName);
-            const anyType = this.createOrGetFamixType('any', undefined);
-            (importedEntity as Famix.StructuralEntity).setDeclaredType(anyType);
+            importedEntity.fullyQualifiedName = pathName;
+            const anyType = this.createOrGetFamixType('any', importDeclaration);
+            (importedEntity as Famix.StructuralEntity).declaredType = anyType;
         } else {  // default imports, e.g. import ClassW from "./complexExportModule";  
             importedEntityName = importElement.getText();
             pathName = pathName + (isDefaultExport ? "defaultExport" : "namespaceExport");
             importedEntity = new Famix.NamedEntity();
-            importedEntity.setName(importedEntityName);
+            importedEntity.name = importedEntityName;
+            importedEntity.fullyQualifiedName = pathName;
             this.makeFamixIndexFileAnchor(importElement, importedEntity);
-            importedEntity.setFullyQualifiedName(pathName);
         }
         // I don't think it should be added to the repository if it exists already
         if (!isInExports) this.famixRep.addElement(importedEntity);
         const importerFullyQualifiedName = FQNFunctions.getFQN(importer);
         const fmxImporter = this.famixRep.getFamixEntityByFullyQualifiedName(importerFullyQualifiedName) as Famix.Module;
-        fmxImportClause.setImportingEntity(fmxImporter);
-        fmxImportClause.setImportedEntity(importedEntity);
+        fmxImportClause.importingEntity = fmxImporter;
+        fmxImportClause.importedEntity = importedEntity;
         if (importDeclaration instanceof ImportEqualsDeclaration) {
-            fmxImportClause.setModuleSpecifier(importDeclaration?.getModuleReference().getText() as string);
+            fmxImportClause.moduleSpecifier = importDeclaration?.getModuleReference().getText() as string;
         } else {
-            fmxImportClause.setModuleSpecifier(importDeclaration?.getModuleSpecifierValue() as string);
+            fmxImportClause.moduleSpecifier = importDeclaration?.getModuleSpecifierValue() as string;
         }
     
-        logger.debug(`createFamixImportClause: ${fmxImportClause.getImportedEntity()?.getName()} (of type ${
-            Helpers.getSubTypeName(fmxImportClause.getImportedEntity())}) is imported by ${fmxImportClause.getImportingEntity()?.getName()}`);
+        logger.debug(`createFamixImportClause: ${fmxImportClause.importedEntity?.name} (of type ${
+            Helpers.getSubTypeName(fmxImportClause.importedEntity)}) is imported by ${fmxImportClause.importingEntity?.name}`);
 
         fmxImporter.addOutgoingImport(fmxImportClause);
 
         this.famixRep.addElement(fmxImportClause);
 
-        this.fmxElementObjectMap.set(fmxImportClause,importDeclaration);
+        if (importDeclaration) this.fmxElementObjectMap.set(fmxImportClause, importDeclaration);
     }
 
     /**
@@ -1108,7 +1215,7 @@ export class EntityDictionary {
      * @param arrowExpression An Expression
      * @returns The Famix model of the variable
      */
-    public createFamixArrowFunction(arrowExpression: Expression ,currentCC: unknown): Famix.ArrowFunction | Famix.ParametricArrowFunction {
+    public createFamixArrowFunction(arrowExpression: Expression, currentCC: { [key: string]: number } ): Famix.ArrowFunction | Famix.ParametricArrowFunction {
         
         let fmxArrowFunction: Famix.ArrowFunction | Famix.ParametricArrowFunction;
 
@@ -1133,17 +1240,17 @@ export class EntityDictionary {
         }
 
         if (functionName) {
-            fmxArrowFunction.setName(functionName);
+            fmxArrowFunction.name = functionName;
         }
         else {
-            fmxArrowFunction.setName("anonymous");
+            fmxArrowFunction.name = "anonymous";
         }
 
         // Signature of an arrow function is (parameters) => return_type
         const parametersSignature = arrowFunction.getParameters().map(p => p.getText()).join(", ");
         const returnTypeSignature = arrowFunction.getReturnType().getText();
-        fmxArrowFunction.setSignature(`(${parametersSignature}) => ${returnTypeSignature}`);
-        fmxArrowFunction.setCyclomaticComplexity(currentCC[fmxArrowFunction.getName()]);
+        fmxArrowFunction.signature = `(${parametersSignature}) => ${returnTypeSignature}`;
+        fmxArrowFunction.cyclomaticComplexity = currentCC[fmxArrowFunction.name];
 
         let functionTypeName = this.UNKNOWN_VALUE;
         try {
@@ -1153,12 +1260,12 @@ export class EntityDictionary {
         }
 
         const fmxType = this.createOrGetFamixType(functionTypeName, arrowFunction as unknown as FunctionDeclaration);
-        fmxArrowFunction.setDeclaredType(fmxType);
-        fmxArrowFunction.setNumberOfLinesOfCode(arrowFunction.getEndLineNumber() - arrowFunction.getStartLineNumber());
+        fmxArrowFunction.declaredType = fmxType;
+        fmxArrowFunction.numberOfLinesOfCode = arrowFunction.getEndLineNumber() - arrowFunction.getStartLineNumber();
         const parameters = arrowFunction.getParameters();
-        fmxArrowFunction.setNumberOfParameters(parameters.length);
-        fmxArrowFunction.setNumberOfStatements(arrowFunction.getStatements().length);
-
+        fmxArrowFunction.numberOfParameters = parameters.length;
+        fmxArrowFunction.numberOfStatements = arrowFunction.getStatements().length;
+        initFQN(arrowExpression as unknown as TSMorphObjectType, fmxArrowFunction);
         this.makeFamixIndexFileAnchor(arrowExpression as unknown as TSMorphObjectType, fmxArrowFunction);
         this.famixRep.addElement(fmxArrowFunction);
         this.fmxElementObjectMap.set(fmxArrowFunction,arrowFunction as unknown as TSMorphObjectType);
@@ -1175,11 +1282,11 @@ export class EntityDictionary {
         
         const fmxConcretisation : Famix.Concretisation = new Famix.Concretisation();              
         
-        fmxConcretisation.setConcreteEntity(conEntity);
-        fmxConcretisation.setGenericEntity(genEntity);
-        this.fmxElementObjectMap.set(fmxConcretisation,null);
+        fmxConcretisation.concreteEntity = conEntity;
+        fmxConcretisation.genericEntity = genEntity;
+        // this.fmxElementObjectMap.set(fmxConcretisation,null);
         this.famixRep.addElement(fmxConcretisation);    
-        const parameterConcretisation = this.createFamixParameterConcrestisation(fmxConcretisation);
+        const parameterConcretisation = this.createFamixParameterConcretisation(fmxConcretisation);
             
         return fmxConcretisation;
     }
@@ -1189,41 +1296,47 @@ export class EntityDictionary {
      * @param concretisation A FamixConcretisation
      * @returns The Famix model of the ParameterConcrestisation
      */
-    public createFamixParameterConcrestisation(concretisation: Famix.Concretisation): Famix.ParameterConcretisation {
-        const conClass = concretisation.getConcreteEntity();
-        const genClass = concretisation.getGenericEntity();
-        const parameterConcretisations = this.famixRep._getAllEntitiesWithType("ParameterConcretisation");
-        const concreteParameters = conClass.getConcreteParameters();
-        const genericParameters = genClass.getGenericParameters();
+    public createFamixParameterConcretisation(concretisation: Famix.Concretisation): Famix.ParameterConcretisation | undefined{
+        const conClass = concretisation.concreteEntity;
+        const genClass = concretisation.genericEntity;
+        logger.debug(`Creating parameter concretisation between ${conClass.fullyQualifiedName} and ${genClass.fullyQualifiedName}`);
+        const parameterConcretisations = this.famixRep._getAllEntitiesWithType("ParameterConcretisation") as Set<Famix.ParameterConcretisation>;
+        const concreteParameters = conClass.concreteParameters;
+        const genericParameters = genClass.genericParameters;
         
         let conClassTypeParametersIterator = concreteParameters.values();
         let genClassTypeParametersIterator = genericParameters.values();
-        let fmxParameterConcretisation : Famix.ParameterConcretisation;
+        let fmxParameterConcretisation : Famix.ParameterConcretisation | undefined = undefined;
 
         for (let i = 0; i < genericParameters.size; i++) {
-            const conClassTypeParameter = conClassTypeParametersIterator.next().value;
-            const genClassTypeParameter = genClassTypeParametersIterator.next().value;
+            const conClassTypeParameter = conClassTypeParametersIterator.next().value as Famix.ParameterType;
+            const genClassTypeParameter = genClassTypeParametersIterator.next().value as Famix.ParameterType;
             let createParameterConcretisation : boolean = true;
-            if(conClassTypeParameter && genClassTypeParameter && conClassTypeParameter.getName() != genClassTypeParameter.getName()){
+            if(conClassTypeParameter && genClassTypeParameter && conClassTypeParameter.name != genClassTypeParameter.name){
                 parameterConcretisations.forEach((param : Famix.ParameterConcretisation) => {
-                    if (conClassTypeParameter.getName() == param.getConcreteParameter().getName() && genClassTypeParameter.getName() == param.getGenericParameter().getName()) {
+                    if (conClassTypeParameter.name == param.concreteParameter.name && genClassTypeParameter.name == param.genericParameter.name) {
                         createParameterConcretisation = false;
                         fmxParameterConcretisation = param;
                     }
                 })
                 if (createParameterConcretisation) {
                     fmxParameterConcretisation = new Famix.ParameterConcretisation();
-                    fmxParameterConcretisation.setGenericParameter(genClassTypeParameter);
-                    fmxParameterConcretisation.setConcreteParameter(conClassTypeParameter);
+                    fmxParameterConcretisation.genericParameter = genClassTypeParameter;
+                    fmxParameterConcretisation.concreteParameter = conClassTypeParameter;
                     fmxParameterConcretisation.addConcretisation(concretisation);
-                    this.fmxElementObjectMap.set(fmxParameterConcretisation,null);
+                    // this.fmxElementObjectMap.set(fmxParameterConcretisation,null);
                 } else {
+                    if (!fmxParameterConcretisation) {
+                        throw new Error(`fmxParameterConcretisation was undefined for concretisation with generic parameter ${genClassTypeParameter.name} and concrete parameter ${conClassTypeParameter.name}`);
+                    }
                     fmxParameterConcretisation.addConcretisation(concretisation);
                 }
                 this.famixRep.addElement(fmxParameterConcretisation);
             }
         }
-    
+        if (!fmxParameterConcretisation) {
+            logger.error(`fmxParameterConcretisation was undefined for concretisation with concrete entity ${conClass.fullyQualifiedName} and generic entity ${genClass.fullyQualifiedName}`);
+        }
         return fmxParameterConcretisation;
 
     }
@@ -1256,10 +1369,10 @@ export class EntityDictionary {
                     let EntityDeclaration;
                     let genEntity;
                     if (superEntity instanceof ExpressionWithTypeArguments) {
-                        EntityDeclaration = entity.getExpression().getSymbol().getDeclarations()[0] as ClassDeclaration;
+                        EntityDeclaration = entity.getExpression().getSymbol()?.getDeclarations()[0] as ClassDeclaration;
                         genEntity = this.createOrGetFamixClass(EntityDeclaration) as Famix.ParametricClass;
                     } else {
-                        EntityDeclaration = entity.getExpression().getSymbol().getDeclarations()[0] as InterfaceDeclaration;
+                        EntityDeclaration = entity.getExpression().getSymbol()?.getDeclarations()[0] as InterfaceDeclaration;
                         genEntity = this.createOrGetFamixInterface(EntityDeclaration) as Famix.ParametricInterface;
                     }
                     const genParams = EntityDeclaration.getTypeParameters().map((param) => param.getText());
@@ -1268,10 +1381,10 @@ export class EntityDictionary {
                     if (!Helpers.arraysAreEqual(conParams,genParams)) {
                         let conEntity;
                         conEntity = this.createOrGetFamixConcreteElement(genEntity,EntityDeclaration,args);
-                        const concretisations = this.famixRep._getAllEntitiesWithType("Concretisation");
+                        const concretisations = this.famixRep._getAllEntitiesWithType("Concretisation") as Set<Famix.Concretisation>;
                         let createConcretisation : boolean = true;
                         concretisations.forEach((conc : Famix.Concretisation) => {
-                            if (genEntity.getFullyQualifiedName() == conc.getGenericEntity().getFullyQualifiedName() && conc.getConcreteEntity().getFullyQualifiedName() == conEntity.getFullyQualifiedName()){
+                            if (genEntity.fullyQualifiedName == conc.genericEntity.fullyQualifiedName && conc.concreteEntity.fullyQualifiedName == conEntity.fullyQualifiedName){
                                 createConcretisation = false;
                             }
                         });
@@ -1282,7 +1395,8 @@ export class EntityDictionary {
                     }
                 }
             });
-        }           
+        }
+        // TODO: This function seems unfinished
     }    
     
 
@@ -1309,10 +1423,10 @@ export class EntityDictionary {
                     if (!Helpers.arraysAreEqual(conParams,genParams)) {
                         let conEntity;
                         conEntity = this.createOrGetFamixConcreteElement(genEntity,cls,instance.getTypeArguments());
-                        const concretisations = this.famixRep._getAllEntitiesWithType("Concretisation");
+                        const concretisations = this.famixRep._getAllEntitiesWithType("Concretisation") as Set<Famix.Concretisation>;
                         let createConcretisation : boolean = true;
                         concretisations.forEach((conc : Famix.Concretisation) => {
-                            if (genEntity.getFullyQualifiedName() == conc.getGenericEntity().getFullyQualifiedName() && conc.getConcreteEntity().getFullyQualifiedName() == conEntity.getFullyQualifiedName()){
+                            if (genEntity.fullyQualifiedName == conc.genericEntity.fullyQualifiedName && conc.concreteEntity.fullyQualifiedName == conEntity.fullyQualifiedName){
                                 createConcretisation = false;
                             }
                         });
@@ -1324,6 +1438,7 @@ export class EntityDictionary {
                 }
             })
         }
+        // TODO: This function seems unfinished
     }
 
     /**
@@ -1336,11 +1451,14 @@ export class EntityDictionary {
             const genParams = element.getTypeParameters().map(param => param.getText());
             const uses = element.findReferencesAsNodes();    
             uses.forEach(usage => {
-                let currentNode = usage;
+                let currentNode: Node | undefined = usage;
 
                 while (currentNode) {
                     if (currentNode.getKind() === SyntaxKind.CallExpression) {
                         const callExpression = currentNode.asKind(SyntaxKind.CallExpression);
+                        if (!callExpression) {
+                            throw new Error(`CallExpression not found for ${currentNode.getText()}`);
+                        }
                         const instanceIsGeneric = callExpression.getTypeArguments().length > 0;
                         if (instanceIsGeneric) {
                             const args = callExpression.getTypeArguments();
@@ -1348,16 +1466,16 @@ export class EntityDictionary {
                             if (!Helpers.arraysAreEqual(conParams,genParams)) {
                                 let genElement;
                                 if(element instanceof FunctionDeclaration){
-                                    genElement = this.createOrGetFamixFunction(element,0) as Famix.ParametricFunction;
+                                    genElement = this.createOrGetFamixFunction(element, {}) as Famix.ParametricFunction;
                                 } else {
-                                    genElement = this.createOrGetFamixMethod(element,0) as Famix.ParametricMethod;
+                                    genElement = this.createOrGetFamixMethod(element, {}) as Famix.ParametricMethod;
                                 }
                                 let concElement;
                                 concElement = this.createOrGetFamixConcreteElement(genElement,element,args);
-                                const concretisations = this.famixRep._getAllEntitiesWithType("Concretisation");
+                                const concretisations = this.famixRep._getAllEntitiesWithType("Concretisation") as Set<Famix.Concretisation>;
                                 let createConcretisation : boolean = true;
                                 concretisations.forEach((conc : Famix.Concretisation) => {
-                                    if (genElement.getFullyQualifiedName() == conc.getGenericEntity().getFullyQualifiedName() && conc.getConcreteEntity().getFullyQualifiedName() == concElement.getFullyQualifiedName()){
+                                    if (genElement.fullyQualifiedName == conc.genericEntity.fullyQualifiedName && conc.concreteEntity.fullyQualifiedName == concElement.fullyQualifiedName){
                                         createConcretisation = false;
                                     }
                                 });
@@ -1386,17 +1504,17 @@ export class EntityDictionary {
         superInterfaces.forEach(interfaceType => {
             const interfaceIsGeneric = interfaceType.getTypeArguments().length>0;
             if (interfaceIsGeneric) {
-                const interfaceDeclaration = interfaceType.getExpression().getSymbol().getDeclarations()[0] as InterfaceDeclaration;
+                const interfaceDeclaration = interfaceType.getExpression().getSymbol()?.getDeclarations()[0] as InterfaceDeclaration;
                 const genParams = interfaceDeclaration.getTypeParameters().map((param) => param.getText());
                 const conParams = cls.getHeritageClauses()[0].getTypeNodes()[0].getTypeArguments().map((param) => param.getText());
                 const args = cls.getHeritageClauses()[0].getTypeNodes()[0].getTypeArguments();
                 if (!Helpers.arraysAreEqual(conParams,genParams)) {
                     const genInterface = this.createOrGetFamixInterface(interfaceDeclaration) as Famix.ParametricInterface;
                     const conInterface = this.createOrGetFamixConcreteElement(genInterface,interfaceDeclaration,args);
-                    const concretisations = this.famixRep._getAllEntitiesWithType("Concretisation");
+                    const concretisations = this.famixRep._getAllEntitiesWithType("Concretisation") as Set<Famix.Concretisation>;
                     let createConcretisation : boolean = true;
                     concretisations.forEach((conc : Famix.Concretisation) => {
-                        if (genInterface.getFullyQualifiedName() == conc.getGenericEntity().getFullyQualifiedName() && conc.getConcreteEntity().getFullyQualifiedName() == conInterface.getFullyQualifiedName()){
+                        if (genInterface.fullyQualifiedName == conc.genericEntity.fullyQualifiedName && conc.concreteEntity.fullyQualifiedName == conInterface.fullyQualifiedName){
                             createConcretisation = false;
                         }
                     });
@@ -1425,6 +1543,9 @@ export class EntityDictionary {
                 while (parentNode) {
                     if (parentNode.getKind() === SyntaxKind.TypeReference) {
                         const typeReferenceNode = parentNode.asKind(SyntaxKind.TypeReference);
+                        if (!typeReferenceNode) {
+                            throw new Error(`TypeReferenceNode not found for ${parentNode.getText()}`);
+                        }
                         const typeReferenceNodeIsGeneric = typeReferenceNode.getTypeArguments().length > 0;
                         if (typeReferenceNodeIsGeneric) {}
                             const args = typeReferenceNode.getTypeArguments();
@@ -1438,10 +1559,10 @@ export class EntityDictionary {
                                 }
                                 let concElement;
                                 concElement = this.createOrGetFamixConcreteElement(genElement,element,args);
-                                const concretisations = this.famixRep._getAllEntitiesWithType("Concretisation");
+                                const concretisations = this.famixRep._getAllEntitiesWithType("Concretisation") as Set<Famix.Concretisation>;
                                 let createConcretisation : boolean = true;
                                 concretisations.forEach((conc : Famix.Concretisation) => {
-                                    if (genElement.getFullyQualifiedName() == conc.getGenericEntity().getFullyQualifiedName() && conc.getConcreteEntity().getFullyQualifiedName() == concElement.getFullyQualifiedName()){
+                                    if (genElement.fullyQualifiedName == conc.genericEntity.fullyQualifiedName && conc.concreteEntity.fullyQualifiedName == concElement.fullyQualifiedName){
                                         createConcretisation = false;
                                     }
                                 });
@@ -1462,3 +1583,11 @@ export class EntityDictionary {
         return absolutePath.replace(absolutePathProject, "").slice(1);
     }
 }
+function initFQN(sourceElement: TSMorphObjectType, famixElement: Famix.SourcedEntity) {
+    if (!(sourceElement instanceof CommentRange)) {
+        const fqn = FQNFunctions.getFQN(sourceElement);
+        logger.debug("Setting fully qualified name for " + famixElement.getJSON() + " to " + fqn);
+        (famixElement as Famix.NamedEntity).fullyQualifiedName = fqn;
+    }
+}
+