wip

Author: hvitved

shared/typeinference/codeql/typeinference/internal/TypeInference.qll

@@ -3006,6 +3006,11 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
             exists(e)
           }
 
+          private Type getInferredType0(AccessEnvironment e, AccessPosition apos, TypePath path) {
+            result = this.getInferredType(e, apos, path) and
+            exists(this.getTarget(e))
+          }
+
           Declaration getTarget(AccessEnvironment e) { result = super.getTarget(e) }
         }
       }
@@ -3095,6 +3100,7 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
          * Holds if `invocation` resolves to some target where the return type at `path`
          * may have to be inferred from the context.
          */
+        // todo: also fields
         pragma[nomagic]
         predicate needsContextualTyping(Invocation invocation, TypePath path) {
           exists(Callable target, TypeParameter tp |

swift/ql/test/library-tests/type-inference/basics.swift

@@ -1,71 +1,71 @@
-var topLevelDecl : Int = 0
+var topLevelDecl: Int = 0
 0
-topLevelDecl + 1 // $ type=topLevelDecl:Int
+topLevelDecl + 1  // $ type=topLevelDecl:Int
 
 class C {
-  var myInt : Int
+  var myInt: Int
   // C.init
   init(n: Int) {
-    myInt = n // $ type=n:Int
+    myInt = n  // $ type=n:Int
   }
 
   // C.getMyInt
   func getMyInt() -> Int {
-    return myInt // $ type=.myInt:Int
+    return myInt  // $ type=.myInt:Int
   }
 }
 
-class Derived : C {
+class Derived: C {
   // Derived.init
   init() {
-    super.init(n: 0) // $ type=super:C target=C.init
+    super.init(n: 0)  // $ type=super:C target=C.init
   }
 
   // Derived.callGetMyInt
   func callGetMyInt() -> Int {
-    let x = getMyInt(); // $ type=x:Int target=C.getMyInt
+    let x = getMyInt()  // $ type=x:Int target=C.getMyInt
     return x
   }
 }
 
 class Generic<T> {
-  var value : T
+  var value: T
   // Generic.init
   init(v: T) {
-    value = v // $ type=v:T
+    value = v  // $ type=v:T
   }
 
   // Generic.getValue
   func getValue() -> T {
-    return value // $ type=.value:T
+    return value  // $ type=.value:T
   }
 }
 
-class GenericDerived : Generic<Int> {
+class GenericDerived: Generic<Int> {
   // GenericDerived.init
   init() {
-    super.init(v: 0) // $ type=super@Generic<T>:Int target=Generic.init
+    super.init(v: 0)  // $ type=super@Generic<T>:Int target=Generic.init
   }
 }
 
 func testGeneric() {
-  let g = Generic(v: 42) // $ type=g@Generic<T>:Int target=Generic.init
-  let x = g.getValue() // $ type=x:Int target=Generic.getValue
+  let g = Generic(v: 42)  // $ type=g@Generic<T>:Int target=Generic.init
+  let x = g.getValue()  // $ type=x:Int target=Generic.getValue
 
-  let gd = GenericDerived() // $ type=gd:GenericDerived target=GenericDerived.init
-  let y = gd.getValue() // $ type=y:Int target=Generic.getValue
+  let gd = GenericDerived()  // $ type=gd:GenericDerived target=GenericDerived.init
+  let y = gd.getValue()  // $ type=y:Int target=Generic.getValue
 }
 
 // --- Extensions ---
 
 extension C {
   // C.doubled
   func doubled() -> Int {
-    return myInt * 2 // $ type=.myInt:Int
+    return myInt * 2  // $ type=.myInt:Int
   }
 }
 
 func testExtension() {
-  let obj = C(n: 10) // $ target=C.init
-  let d = obj.doubled() // $ type=d:Int target=C.doubled
+  let obj = C(n: 10)  // $ target=C.init
+  let d = obj.doubled()  // $ type=d:Int target=C.doubled
 }

unified/ql/lib/codeql/unified/internal/ExprPositions.qll

@@ -29,6 +29,8 @@ predicate isInTypeContext(Expr expr) {
   or
   expr = any(ClassLikeDeclaration c).getExtensionTarget()
   or
+  expr = any(GenericTypeExpr gte).getATypeArgument()
+  or
   expr.getParent() instanceof TypeConstraint
   or
   isInTypeContext(expr.getEnclosingExpr())

unified/ql/lib/codeql/unified/internal/dataflow/CallGraph.qll

@@ -1,16 +1,7 @@
 private import unified
 private import AllDataFlow
-private import codeql.unified.internal.NameBinding as N
-
-private Callable getCallableFromNameBinding(NameBinding binding) {
-  binding = result.(FunctionDeclaration).getNameNode()
-}
+private import codeql.unified.internal.typeinference.TypeInference as T
 
 DataFlowCallable viableCallable(DataFlowCall c) {
-  exists(CallExpr call, Callable callable, NameBinding target |
-    c.asExplicitCall() = call and
-    target = N::getStaticBindingTarget(N::getIdentifierFromRef(call.getCallee())) and
-    callable = getCallableFromNameBinding(target) and
-    result.asSourceCallable() = callable
-  )
+  result.asSourceCallable() = T::resolveCallTarget(c.asExplicitCall(), _)
 }