Update

Author: dstallenberg

src/analysis/static/JavaScriptTargetPool.ts

@@ -287,6 +287,7 @@ export class JavaScriptTargetPool extends TargetPool {
 
     const objects: ComplexObject[] = []
 
+    //TODO the entire project should be searched for complex object types instead of dependencies only
     const objectGenerator = new ObjectGenerator()
     objects.push(...objectGenerator.generate(absoluteTargetPath, ast))
 

src/analysis/static/types/resolving/TypeResolver.ts

@@ -7,7 +7,7 @@ import { ComplexObject } from "../discovery/object/ComplexObject";
 // TODO would be better if the typeresolver works for all files
 export abstract class TypeResolver {
   private _relationTyping: Map<Relation, Typing> // TODO should be probability distribution per typing
-  private _elementTyping: Map<Element, Typing> // TODO should be probability distribution per typing
+  private _elementTyping: Map<Element, Map<Typing, number>> // TODO should be probability distribution per typing
 
   private _relationFullyResolved: Set<Relation> // TODO should be probability distribution per typing
 
@@ -24,7 +24,7 @@ export abstract class TypeResolver {
     return this._relationTyping;
   }
 
-  get elementTyping(): Map<Element, Typing> {
+  get elementTyping(): Map<Element, Map<Typing, number>> {
     return this._elementTyping;
   }
 

src/analysis/static/types/resolving/logic/TypeResolverInference.ts

@@ -5,7 +5,7 @@ import { Scope, ScopeType } from "../../discovery/Scope";
 import { Element, isInstanceOfElement } from "../../discovery/Element";
 import { ComplexObject } from "../../discovery/object/ComplexObject";
 
-export class TypeResolverInference extends TypeResolver{
+export class TypeResolverInference extends TypeResolver {
 
   private wrapperElementIsRelation: Map<string, Relation>
 
@@ -19,9 +19,9 @@ export class TypeResolverInference extends TypeResolver{
       const typingsType = elementTypeToTypingType(element.type)
 
       if (typingsType) {
-        this.elementTyping.set(element, {
-          type: typingsType
-        })
+        const probabilities = new Map()
+        probabilities.set({ type: typingsType }, 1)
+        this.elementTyping.set(element, probabilities)
         somethingSolved = true
       }
     }
@@ -54,9 +54,10 @@ export class TypeResolverInference extends TypeResolver{
 
       // TODO find out wether function property or regular property
 
+      const probabilities = new Map()
+
       // find best matching object
-      let bestScore = -1
-      let bestMatch = objects[0]
+      let total = 0
       for (const object of objects) {
         let score = 0
         for (const prop of properties) {
@@ -65,22 +66,23 @@ export class TypeResolverInference extends TypeResolver{
           }
         }
 
-        if (score > bestScore) {
-          bestScore = score
-          bestMatch = object
+        // atleast score of one?
+        if (score > 0) {
+          probabilities.set(<ComplexTyping>{
+            type: TypingType.Object,
+            name: object.name,
+            import: object.import,
+          }, score)
+          total += score
         }
       }
 
-      if (bestScore === 0) {
-        continue
+      for (const obj of probabilities.keys()) {
+        probabilities.set(obj, probabilities.get(obj) / total)
       }
 
-      this.elementTyping.set(element, <ComplexTyping>{
-        type: TypingType.Object,
-        name: bestMatch.name,
-        import: bestMatch.import,
-      })
-      console.log(element, this.elementTyping.get(element))
+      this.elementTyping.set(element, probabilities)
+      // console.log(element, this.elementTyping.get(element))
       somethingSolved = true
     }
     // console.log(scopes)