ts2famix 1.4.1 → 2.0.0

package/src/famix_functions/helpers_creation.ts

@@ -1,6 +1,7 @@
 import * as Famix from "../lib/famix/src/model/famix";
 import { logger } from "../analyze";
 import { ConstructorDeclaration, Identifier, FunctionDeclaration, MethodDeclaration, MethodSignature, PropertyDeclaration, PropertySignature, VariableDeclaration, ParameterDeclaration, GetAccessorDeclaration, SetAccessorDeclaration, EnumMember, TypeAliasDeclaration, Node, SyntaxKind, FunctionExpression } from "ts-morph";
+import { TypeDeclaration } from "./EntityDictionary";
 
 interface SearchParameters {
     searchArray: string[];
@@ -72,6 +73,31 @@ export function findAncestor(node: Identifier): Node {
  * @param element A ts-morph element
  * @returns The ancestor of the ts-morph element
  */
-export function findTypeAncestor(element: TypeAliasDeclaration | PropertyDeclaration | PropertySignature | MethodDeclaration | ConstructorDeclaration | MethodSignature | GetAccessorDeclaration | SetAccessorDeclaration | FunctionDeclaration | FunctionExpression | ParameterDeclaration | VariableDeclaration | EnumMember): Node {
+export function findTypeAncestor(element: TypeDeclaration): 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);
-}
+}
+
+export function arraysAreEqual(array1: string[], array2: string[]): boolean {
+    if (array1 && array2 ) {
+        return array1.length === array2.length && array1.every((value, index) => value === array2[index]);
+    }
+}
+
+export function replaceLastBetweenTags(input: string, replacement: string): string {
+    const lastTagIndex = input.lastIndexOf('<');
+    
+    if (lastTagIndex === -1) {
+        return input; // Return the original string if no tags are found
+    }
+
+    const closingTagIndex = input.indexOf('>', lastTagIndex);
+    
+    if (closingTagIndex === -1) {
+        return input; // Return the original string if no closing tag is found
+    }
+
+    const beforeTag = input.substring(0, lastTagIndex + 1); // Include '<'
+    const afterTag = input.substring(closingTagIndex); // Include '>'
+
+    return beforeTag + replacement + afterTag;
+}

package/src/fqn.ts

@@ -1,16 +1,104 @@
-import * as ts from "ts-morph";
-import { entityDictionary } from "./analyze";
+import { ArrowFunction, CallExpression, ClassDeclaration, ClassExpression, ConstructorDeclaration, Decorator, EnumDeclaration, FunctionDeclaration, FunctionExpression, GetAccessorDeclaration, Identifier, ImportDeclaration, ImportEqualsDeclaration, InterfaceDeclaration, MethodDeclaration, MethodSignature, ModuleDeclaration, Node, PropertyDeclaration, SetAccessorDeclaration, SourceFile, ts, TypeParameterDeclaration, VariableDeclaration } from "ts-morph";
+import { entityDictionary, logger } from "./analyze";
 import path from "path";
+import { TypeDeclaration } from "./famix_functions/EntityDictionary";
+
+
+type FQNNode = SourceFile | VariableDeclaration | ArrowFunction | Identifier | MethodDeclaration | MethodSignature | FunctionDeclaration | FunctionExpression | PropertyDeclaration | TypeDeclaration | EnumDeclaration | ImportDeclaration | ImportEqualsDeclaration | CallExpression | GetAccessorDeclaration | SetAccessorDeclaration | ConstructorDeclaration | TypeParameterDeclaration | ClassDeclaration | InterfaceDeclaration | Decorator | ModuleDeclaration;
+
+function isFQNNode(node: Node): node is FQNNode {
+    return Node.isVariableDeclaration(node) || Node.isArrowFunction(node) || Node.isIdentifier(node) || Node.isMethodDeclaration(node) || Node.isClassDeclaration(node) || Node.isClassExpression(node) || Node.isDecorator(node) || Node.isModuleDeclaration(node) || Node.isCallExpression(node);
+
+}
+
+export function getFQN(node: FQNNode | Node): string {
+    const absolutePathProject = entityDictionary.famixRep.getAbsolutePath();
+
+    const sourceFile = node.getSourceFile();
+    let parts: string[] = [];
+    let currentNode: Node | undefined = node;
+
+    while (currentNode && !Node.isSourceFile(currentNode)) {
+        const { line, column } = sourceFile.getLineAndColumnAtPos(currentNode.getStart());
+        const lc = `${line}:${column}`;
+        if (Node.isClassDeclaration(currentNode) || 
+            Node.isClassExpression(currentNode) || 
+            Node.isInterfaceDeclaration(currentNode) ||
+            Node.isFunctionDeclaration(currentNode) || 
+            Node.isMethodDeclaration(currentNode) || 
+            Node.isModuleDeclaration(currentNode) || 
+            Node.isVariableDeclaration(currentNode) || 
+            Node.isGetAccessorDeclaration(currentNode) ||
+            Node.isSetAccessorDeclaration(currentNode) ||
+            Node.isIdentifier(currentNode)) {
+            let name = Node.isIdentifier(currentNode) ? currentNode.getText() 
+                : getNameOfNode(currentNode) /* currentNode.getName() */ || 'Unnamed_' + currentNode.getKindName() + `(${lc})`;
+            parts.unshift(name);
+        } else if (Node.isArrowFunction(currentNode) || 
+                   Node.isBlock(currentNode) || 
+                   Node.isForInStatement(currentNode) || 
+                   Node.isForOfStatement(currentNode) || 
+                   Node.isForStatement(currentNode) || 
+                   Node.isCatchClause(currentNode)) {
+            parts.unshift(`${currentNode.getKindName()}(${lc})`);
+        } else if (Node.isConstructorDeclaration(currentNode)) {
+            parts.unshift(`constructor`);
+        } else {
+            // For other kinds, you might want to handle them specifically or ignore
+            //console.log(`Ignoring node kind: ${currentNode.getKindName()}`);
+        }
+        currentNode = currentNode.getParent();
+    }
+
+
+
+    // Prepend the relative path of the source file
+    const relativePath = entityDictionary.convertToRelativePath(
+        path.normalize(sourceFile.getFilePath()), 
+                       absolutePathProject).replace(/\\/sg, "/");
+    parts.unshift(`{${relativePath}}`);
+    const fqn = parts.join(".") + `[${node.getKindName()}]`;  // disambiguate
+
+    logger.debug(fqn);
+    return fqn;
+}
+
+
+export function getUniqueFQN(node: Node): string | undefined {
+    const absolutePathProject = entityDictionary.famixRep.getAbsolutePath();
+    let parts: string[] = [];
+
+    if (node instanceof SourceFile) {
+        return entityDictionary.convertToRelativePath(path.normalize(node.getFilePath()), absolutePathProject).replace(/\\/g, "/");
+    }
+
+    while (node) {
+        if (Node.isSourceFile(node)) {
+            const relativePath = entityDictionary.convertToRelativePath(path.normalize(node.getFilePath()), absolutePathProject).replace(/\\/g, "/");
+            parts.unshift(relativePath); // Add file path at the start
+            break;
+        } else if (node.getSymbol()) {
+            const name = node.getSymbol()!.getName();
+            // For anonymous nodes, use kind and position as unique identifiers
+            const identifier = name !== "__computed" ? name : `${node.getKindName()}_${node.getStartLinePos()}`;
+            parts.unshift(identifier);
+        }
+        node = node.getParent();
+    }
+
+    return parts.join("::");
+}
+
 
 /**
  * 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
  */
-export function getFQN(node: ts.Node): string {
+export function oldGetFQN(node: Node): string {
     const absolutePathProject = entityDictionary.famixRep.getAbsolutePath();
     
-    if (node instanceof ts.SourceFile) {
+    if (node instanceof SourceFile) {
         return entityDictionary.convertToRelativePath(path.normalize(node.getFilePath()), 
             absolutePathProject).replace(/\\/sg, "/");
     }
@@ -67,7 +155,7 @@ export function getFQN(node: ts.Node): string {
  * @param a A node
  * @returns The name of the node, or an empty string if it doesn't have one
  */
-export function getNameOfNode(a: ts.Node<ts.ts.Node>): string {
+export function getNameOfNode(a: Node): string {
     switch (a.getKind()) {
         case ts.SyntaxKind.SourceFile:
             return a.asKind(ts.SyntaxKind.SourceFile)?.getBaseName();
@@ -76,10 +164,18 @@ export function getNameOfNode(a: ts.Node<ts.ts.Node>): string {
             return a.asKind(ts.SyntaxKind.ModuleDeclaration)?.getName(); 
 
         case ts.SyntaxKind.ClassDeclaration:
-            return a.asKind(ts.SyntaxKind.ClassDeclaration)?.getName();
+            if (a.asKind(ts.SyntaxKind.ClassDeclaration).getTypeParameters().length>0){
+                return a.asKind(ts.SyntaxKind.ClassDeclaration)?.getName()+getParameters(a);
+            } else {
+                return a.asKind(ts.SyntaxKind.ClassDeclaration)?.getName();
+            }
 
         case ts.SyntaxKind.InterfaceDeclaration:
-            return a.asKind(ts.SyntaxKind.InterfaceDeclaration)?.getName();
+            if (a.asKind(ts.SyntaxKind.InterfaceDeclaration).getTypeParameters().length>0){
+                return a.asKind(ts.SyntaxKind.InterfaceDeclaration)?.getName()+getParameters(a);
+            } else {
+                return a.asKind(ts.SyntaxKind.InterfaceDeclaration)?.getName();
+            }
                 
         case ts.SyntaxKind.PropertyDeclaration:
             return a.asKind(ts.SyntaxKind.PropertyDeclaration)?.getName();    
@@ -88,7 +184,11 @@ export function getNameOfNode(a: ts.Node<ts.ts.Node>): string {
             return a.asKind(ts.SyntaxKind.PropertySignature)?.getName();    
     
         case ts.SyntaxKind.MethodDeclaration:
-            return a.asKind(ts.SyntaxKind.MethodDeclaration)?.getName();
+            if (a.asKind(ts.SyntaxKind.MethodDeclaration).getTypeParameters().length>0){
+                return a.asKind(ts.SyntaxKind.MethodDeclaration)?.getName()+getParameters(a);
+            } else {
+                return a.asKind(ts.SyntaxKind.MethodDeclaration)?.getName();
+            }
 
         case ts.SyntaxKind.MethodSignature:
             return a.asKind(ts.SyntaxKind.MethodSignature)?.getName();   
@@ -100,7 +200,11 @@ export function getNameOfNode(a: ts.Node<ts.ts.Node>): string {
             return a.asKind(ts.SyntaxKind.SetAccessor)?.getName();
     
         case ts.SyntaxKind.FunctionDeclaration:
-            return a.asKind(ts.SyntaxKind.FunctionDeclaration)?.getName();
+            if (a.asKind(ts.SyntaxKind.FunctionDeclaration).getTypeParameters().length>0){
+                return a.asKind(ts.SyntaxKind.FunctionDeclaration)?.getName()+getParameters(a);
+            } else {
+                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";
@@ -133,4 +237,22 @@ export function getNameOfNode(a: ts.Node<ts.ts.Node>): string {
             // ancestor hasn't got a useful name
             return "";
         }
-}
+}
+
+/**
+ * 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
+ */
+export function getParameters(a: Node): string {
+    switch (a.getKind()) {
+        case ts.SyntaxKind.ClassDeclaration:    
+            return "<" + a.asKind(ts.SyntaxKind.ClassDeclaration)?.getTypeParameters().map(tp => tp.getName()).join(", ") + ">";
+        case ts.SyntaxKind.InterfaceDeclaration:
+            return "<" + a.asKind(ts.SyntaxKind.InterfaceDeclaration)?.getTypeParameters().map(tp => tp.getName()).join(", ") + ">";
+        case ts.SyntaxKind.MethodDeclaration:
+            return "<" + a.asKind(ts.SyntaxKind.MethodDeclaration)?.getTypeParameters().map(tp => tp.getName()).join(", ") + ">";
+        case ts.SyntaxKind.FunctionDeclaration:
+            return "<" + a.asKind(ts.SyntaxKind.FunctionDeclaration)?.getTypeParameters().map(tp => tp.getName()).join(", ") + ">";
+    }
+}

package/src/lib/famix/src/famix_repository.ts

@@ -1,5 +1,5 @@
 import { FamixBaseElement } from "./famix_base_element";
-import { Class, Interface, Namespace, Variable, Method, Function as FamixFunctionEntity, Type, NamedEntity, ScriptEntity, Module, SourceLanguage } from "./model/famix";
+import { Class, Interface, Variable, Method, ArrowFunction, Function as FamixFunctionEntity, Type, NamedEntity, ScriptEntity, Module, SourceLanguage } from "./model/famix";
 // 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 } from "ts-morph";
 import * as Famix from "./model/famix";
 import { TSMorphObjectType } from "../../../famix_functions/EntityDictionary";
@@ -10,7 +10,7 @@ export class FamixRepository {
   private elements = new Set<FamixBaseElement>(); // All Famix elements
   private famixClasses = new Set<Class>(); // All Famix classes
   private famixInterfaces = new Set<Interface>(); // All Famix interfaces
-  private famixNamespaces = new Set<Namespace>(); // All Famix namespaces
+  private famixModules = new Set<Module>(); // All Famix namespaces
   private famixMethods = new Set<Method>(); // All Famix methods
   private famixVariables = new Set<Variable>(); // All Famix variables
   private famixFunctions = new Set<FamixFunctionEntity>(); // All Famix functions
@@ -139,16 +139,16 @@ export class FamixRepository {
    * @param name A namespace name
    * @returns The Famix namespace corresponding to the name or undefined if it doesn't exist
    */
-  public _getFamixNamespace(fullyQualifiedName: string): Namespace | undefined {
-    return Array.from(this.famixNamespaces.values()).find(ns => ns.getFullyQualifiedName() === fullyQualifiedName);
+  public _getFamixModule(fullyQualifiedName: string): Module | undefined {
+    return Array.from(this.famixModules.values()).find(ns => ns.getFullyQualifiedName() === fullyQualifiedName);
   }
 
   /**
    * Gets all Famix namespaces
    * @returns All Famix namespaces
    */
-  public _getFamixNamespaces(): Set<Namespace> {
-    return new Set(Array.from(this.famixNamespaces.values()));
+  public _getFamixModules(): Set<Module> {
+    return new Set(Array.from(this.famixModules.values()));
   }
 
   /**
@@ -212,13 +212,13 @@ export class FamixRepository {
       this.famixClasses.add(element);
     } else if (element instanceof Interface) {
       this.famixInterfaces.add(element);
-    } else if (element instanceof Namespace) {
-      this.famixNamespaces.add(element);
+    } else if (element instanceof Module) {
+      this.famixModules.add(element);
     } else if (element instanceof Variable) {
       this.famixVariables.add(element);
     } else if (element instanceof Method) {
       this.famixMethods.add(element);
-    } else if (element instanceof FamixFunctionEntity) {
+    } else if (element instanceof FamixFunctionEntity || element instanceof ArrowFunction) {
       this.famixFunctions.add(element);
     } else if (element instanceof ScriptEntity || element instanceof Module) {
       this.famixFiles.add(element);

package/src/lib/famix/src/model/famix/access.ts

@@ -1,9 +1,9 @@
 import { FamixJSONExporter } from "../../famix_JSON_exporter";
 import { StructuralEntity } from "./structural_entity";
-import { Association } from "./association";
 import { ContainerEntity } from "./container_entity";
+import { Entity } from "./entity";
 
-export class Access extends Association {
+export class Access extends Entity {
 
   private accessor: ContainerEntity;
 

package/src/lib/famix/src/model/famix/alias.ts

@@ -35,7 +35,7 @@ export class Alias extends NamedEntity {
 
   public addPropertiesToExporter(exporter: FamixJSONExporter): void {
     super.addPropertiesToExporter(exporter);
-    exporter.addProperty("parentEntity", this.getParentEntity());
+    exporter.addProperty("parentType", this.getParentEntity());
     exporter.addProperty("aliasedEntity", this.getAliasedEntity());
   }
 }

package/src/lib/famix/src/model/famix/arrowFunction.ts

@@ -0,0 +1,15 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { BehavioralEntity } from "./behavioral_entity";
+
+export class ArrowFunction extends BehavioralEntity {
+
+  public getJSON(): string {
+    const json: FamixJSONExporter = new FamixJSONExporter("ArrowFunction", this);
+    this.addPropertiesToExporter(json);
+    return json.getJSON();
+  }
+
+  public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+    super.addPropertiesToExporter(exporter);
+  }
+}

package/src/lib/famix/src/model/famix/behavioral_entity.ts

@@ -7,16 +7,6 @@ import { ParameterType } from "./parameter_type";
 
 export class BehavioralEntity extends ContainerEntity {
 
-  private isGeneric: boolean;
-
-  public getIsGeneric(): boolean {
-    return this.isGeneric;
-  }
-
-  public setIsGeneric(isGeneric: boolean): void {
-    this.isGeneric = isGeneric;
-  }
-
   private signature: string;
 
   public getSignature(): string {
@@ -74,19 +64,22 @@ export class BehavioralEntity extends ContainerEntity {
     declaredType.addBehavioralEntityWithDeclaredType(this);
   }
 
-  private typeParameters: Set<ParameterType> = new Set();
+  private genericParameters: Set<ParameterType> = new Set();
 
-  public getParameterTypes(): Set<ParameterType> {
-    return this.typeParameters;
+  public getGenericParameters(): Set<ParameterType> {
+    return this.genericParameters;
   }
 
-  public addParameterType(typeParameter: ParameterType): void {
-    if (!this.typeParameters.has(typeParameter)) {
-      this.typeParameters.add(typeParameter);
-      typeParameter.setParentGeneric(this);
+  public addGenericParameter(genericParameter: ParameterType): void {
+    if (!this.genericParameters.has(genericParameter)) {
+      this.genericParameters.add(genericParameter);
+      genericParameter.setParentGeneric(this);
     }
   }
 
+  clearGenericParameters(): void {
+    this.genericParameters.clear();
+  }
 
   public getJSON(): string {
     const json: FamixJSONExporter = new FamixJSONExporter("BehavioralEntity", this);
@@ -96,12 +89,12 @@ export class BehavioralEntity extends ContainerEntity {
 
   public addPropertiesToExporter(exporter: FamixJSONExporter): void {
     super.addPropertiesToExporter(exporter);
-    exporter.addProperty("isGeneric", this.getIsGeneric());
     exporter.addProperty("signature", this.getSignature());
     exporter.addProperty("parameters", this.getParameters());
     exporter.addProperty("numberOfParameters", this.getNumberOfParameters());
     exporter.addProperty("incomingInvocations", this.getIncomingInvocations());
     exporter.addProperty("declaredType", this.getDeclaredType());
-    exporter.addProperty("typeParameters", this.getParameterTypes());
+    /* don't add the property here, since it doesn't apply to all subclasses */
+//    exporter.addProperty("genericParameters", this.getGenericParameters());
   }
 }

package/src/lib/famix/src/model/famix/comment.ts

@@ -44,7 +44,7 @@ export class Comment extends SourcedEntity {
   public addPropertiesToExporter(exporter: FamixJSONExporter): void {
     super.addPropertiesToExporter(exporter);
     exporter.addProperty("isJSDoc", this.getIsJSDoc());
-    exporter.addProperty("container", this.getContainer());
+    exporter.addProperty("commentedEntity", this.getContainer());
     exporter.addProperty("content", this.getContent());
   }
 }

package/src/lib/famix/src/model/famix/concretisation.ts

@@ -0,0 +1,42 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Entity } from "./entity";
+import { ParametricClass } from "./parametric_class";
+import { ParametricFunction } from "./parametric_function";
+import { ParametricInterface } from "./parametric_interface";
+import { ParametricMethod } from "./parametric_method";
+
+export class Concretisation extends Entity {
+
+    private genericEntity: ParametricClass | ParametricInterface | ParametricFunction | ParametricMethod;
+
+    public getGenericEntity(): ParametricClass | ParametricInterface | ParametricFunction | ParametricMethod {
+      return this.genericEntity;
+    }
+  
+    public setGenericEntity(genericEntity: ParametricClass | ParametricInterface | ParametricFunction | ParametricMethod): void {
+      this.genericEntity = genericEntity;
+    }
+  
+    private concreteEntity: ParametricClass | ParametricInterface | ParametricFunction | ParametricMethod;
+  
+    public getConcreteEntity(): ParametricClass | ParametricInterface | ParametricFunction | ParametricMethod {
+      return this.concreteEntity;
+    }
+  
+    public setConcreteEntity(concreteEntity: ParametricClass | ParametricInterface | ParametricFunction | ParametricMethod): void {
+      this.concreteEntity = concreteEntity;
+    }
+  
+    public getJSON(): string {
+      const json: FamixJSONExporter = new FamixJSONExporter("Concretisation", this);
+      this.addPropertiesToExporter(json);
+      return json.getJSON();
+    }
+  
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+      super.addPropertiesToExporter(exporter);
+      exporter.addProperty("genericEntity", this.getGenericEntity());
+      exporter.addProperty("concreteEntity", this.getConcreteEntity());
+    }
+
+}

package/src/lib/famix/src/model/famix/container_entity.ts

@@ -150,16 +150,16 @@ export class ContainerEntity extends NamedEntity {
 
   public addPropertiesToExporter(exporter: FamixJSONExporter): void {
     super.addPropertiesToExporter(exporter);
-    exporter.addProperty("parentBehaviouralEntity", this.getParentContainerEntity());
-    exporter.addProperty("childrenContainerEntities", this.getChildrenContainerEntities());
+//    exporter.addProperty("parentBehaviouralEntity", this.getParentContainerEntity());
+//    exporter.addProperty("childrenContainerEntities", this.getChildrenContainerEntities());
     exporter.addProperty("cyclomaticComplexity", this.getCyclomaticComplexity());
     exporter.addProperty("numberOfStatements", this.getNumberOfStatements());
-    exporter.addProperty("outgoingReferences", this.getOutgoingReferences());
+//    exporter.addProperty("outgoingReferences", this.getOutgoingReferences());  /* derived ?*/
     exporter.addProperty("numberOfLinesOfCode", this.getNumberOfLinesOfCode());
-    exporter.addProperty("outgoingInvocations", this.getOutgoingInvocations());
-    exporter.addProperty("accesses", this.getAccesses());
+//    exporter.addProperty("outgoingInvocations", this.getOutgoingInvocations());  /* derived ?*/
+//    exporter.addProperty("accesses", this.getAccesses());  /* derived ?*/
     exporter.addProperty("types", this.getTypes());
     exporter.addProperty("functions", this.getFunctions());
-    exporter.addProperty("variables", this.getVariables());
+    exporter.addProperty("localVariables", this.getVariables());
   }
 }

package/src/lib/famix/src/model/famix/decorator.ts

@@ -33,7 +33,7 @@ export class Decorator extends NamedEntity {
 
   public addPropertiesToExporter(exporter: FamixJSONExporter): void {
     super.addPropertiesToExporter(exporter);
-    exporter.addProperty("decoratorExpression", this.getDecoratorExpression());
+    exporter.addProperty("expression", this.getDecoratorExpression());
     exporter.addProperty("decoratedEntity", this.getDecoratedEntity());
   }
 }

package/src/lib/famix/src/model/famix/enum.ts

@@ -26,6 +26,6 @@ export class Enum extends Type {
 
   public addPropertiesToExporter(exporter: FamixJSONExporter): void {
     super.addPropertiesToExporter(exporter);
-    exporter.addProperty("values", this.getValues());
+    exporter.addProperty("enumValues", this.getValues());
   }
 }

package/src/lib/famix/src/model/famix/enum_value.ts

@@ -24,6 +24,6 @@ export class EnumValue extends StructuralEntity {
 
   public addPropertiesToExporter(exporter: FamixJSONExporter): void {
     super.addPropertiesToExporter(exporter);
-    exporter.addProperty("parentEntity", this.getParentEntity());
+    exporter.addProperty("parentEnum", this.getParentEntity());
   }
 }

package/src/lib/famix/src/model/famix/import_clause.ts

@@ -1,9 +1,9 @@
 import { FamixJSONExporter } from "../../famix_JSON_exporter";
-import { Association } from "./association";
+import { Entity } from "./entity";
 import { Module } from "./module";
 import { NamedEntity } from "./named_entity";
 
-export class ImportClause extends Association {
+export class ImportClause extends Entity {
 
   private importingEntity: Module;
 
@@ -48,6 +48,7 @@ export class ImportClause extends Association {
     super.addPropertiesToExporter(exporter);
     exporter.addProperty("importingEntity", this.getImportingEntity());
     exporter.addProperty("importedEntity", this.getImportedEntity());
-    exporter.addProperty("moduleSpecifier", this.getModuleSpecifier());
+    // unknown property below
+//    exporter.addProperty("moduleSpecifier", this.getModuleSpecifier());
   }
 }

package/src/lib/famix/src/model/famix/index.ts

@@ -1,11 +1,11 @@
 export { Access } from "./access";
 export { Accessor } from "./accessor";
 export { Alias } from "./alias";
-export { Association } from "./association";
 export { BehavioralEntity } from "./behavioral_entity";
 export { Class } from "./class";
 export { Comment } from "./comment";
 export { ContainerEntity } from "./container_entity";
+export { Concretisation } from "./concretisation";
 export { Decorator } from "./decorator";
 export { Entity } from "./entity";
 export { EnumValue } from "./enum_value";
@@ -21,12 +21,10 @@ export { Invocation } from "./invocation";
 export { Method } from "./method";
 export { Module } from "./module";
 export { NamedEntity } from "./named_entity";
-export { Namespace } from "./namespace";
 export { ParameterType } from "./parameter_type";
 export { Parameter } from "./parameter";
-export { ParameterizableClass } from "./parameterizable_class";
-export { ParameterizableInterface } from "./parameterizable_interface";
-export { ParameterizedType } from "./parameterized_type";
+export { ParametricClass } from "./parametric_class";
+export { ParametricInterface } from "./parametric_interface";
 export { PrimitiveType } from "./primitive_type";
 export { Reference } from "./reference";
 export { ScopingEntity } from "./scoping_entity";
@@ -38,3 +36,8 @@ export { StructuralEntity } from "./structural_entity";
 export { TextAnchor } from "./text_anchor";
 export { Type } from "./type";
 export { Variable } from "./variable";
+export { ParametricFunction } from "./parametric_function";
+export { ParametricMethod } from "./parametric_method";
+export { ArrowFunction } from "./arrowFunction";
+export { ParametricArrowFunction } from "./parametric_arrow_function";
+export { ParameterConcretisation } from "./parameterConcretisation";

package/src/lib/famix/src/model/famix/indexed_file_anchor.ts

@@ -64,8 +64,8 @@ export class IndexedFileAnchor extends SourceAnchor {
     super.addPropertiesToExporter(exporter);
     exporter.addProperty("startPos", this.getStartPos());
     exporter.addProperty("endPos", this.getEndPos());
-    exporter.addProperty("startLine", this.getStartLine());
-    exporter.addProperty("endLine", this.getEndLine());
+    // exporter.addProperty("startLine", this.getStartLine());
+    // exporter.addProperty("endLine", this.getEndLine());
     exporter.addProperty("fileName", this.getFileName());
   }
 }

package/src/lib/famix/src/model/famix/inheritance.ts

@@ -1,9 +1,9 @@
 import { FamixJSONExporter } from "../../famix_JSON_exporter";
-import { Association } from "./association";
 import { Class } from "./class";
+import { Entity } from "./entity";
 import { Interface } from "./interface";
 
-export class Inheritance extends Association {
+export class Inheritance extends Entity {
 
   private superclass: Class | Interface;
 
@@ -27,7 +27,6 @@ export class Inheritance extends Association {
     subclass.addSuperInheritance(this);
   }
 
-
   public getJSON(): string {
     const json: FamixJSONExporter = new FamixJSONExporter("Inheritance", this);
     this.addPropertiesToExporter(json);
@@ -39,4 +38,4 @@ export class Inheritance extends Association {
     exporter.addProperty("superclass", this.getSuperclass());
     exporter.addProperty("subclass", this.getSubclass());
   }
-}
+}

package/src/lib/famix/src/model/famix/interface.ts

@@ -67,7 +67,7 @@ export class Interface extends Type {
 
   public addPropertiesToExporter(exporter: FamixJSONExporter): void {
     super.addPropertiesToExporter(exporter);
-    exporter.addProperty("properties", this.getProperties());
+    exporter.addProperty("attributes", this.getProperties());
     exporter.addProperty("methods", this.getMethods());
     exporter.addProperty("superInheritances", this.getSuperInheritances());
     exporter.addProperty("subInheritances", this.getSubInheritances());  

package/src/lib/famix/src/model/famix/invocation.ts

@@ -1,10 +1,10 @@
 import { FamixJSONExporter } from "../../famix_JSON_exporter";
 import { NamedEntity } from "./named_entity";
-import { Association } from "./association";
 import { BehavioralEntity } from "./behavioral_entity";
 import { ContainerEntity } from "./container_entity";
+import { Entity } from "./entity";
 
-export class Invocation extends Association {
+export class Invocation extends Entity {
 
   private candidates: Set<BehavioralEntity> = new Set();
 

package/src/lib/famix/src/model/famix/method.ts

@@ -85,7 +85,7 @@ export class Method extends BehavioralEntity {
 
   public addPropertiesToExporter(exporter: FamixJSONExporter): void {
     super.addPropertiesToExporter(exporter);
-    exporter.addProperty("parentEntity", this.getParentEntity());
+    exporter.addProperty("parentType", this.getParentEntity());
     exporter.addProperty("kind", this.getKind());
     exporter.addProperty("isAbstract", this.getIsAbstract());
     exporter.addProperty("isClassSide", this.getIsClassSide());