wip3

Author: hvitved

unified/ql/lib/codeql/unified/internal/typeinference/TypeInferenceConsistency.qll

@@ -21,5 +21,5 @@ query predicate nonUniqueCertainType(AstNode n, TypePath path) {
 
 query predicate typeParameterEscape(AstNode n, TypePath path, TypeParameter tp) {
   tp = inferType(n, path) and
-  forex(AstNode scope | tp.getScope() = scope | not n.getParent*() = scope)
+  not n.getParent*() = tp.getScope()
 }

unified/ql/lib/codeql/unified/internal/typeinference/TypeMention.qll

@@ -5,12 +5,6 @@ private import TypeInferencePlugin as Plugin
 private import codeql.unified.internal.StaticNameBinding
 private import codeql.unified.internal.ExprPositions
 
-// private predicate isTypeParameterAlias(TypeAliasDeclaration alias, int i) {
-//   exists(Unified::TypeParameter tp |
-//     tp = alias.getTypeParameter(i) and
-//     tp.getNameNode() = getTypeFromRef(alias.getType())
-//   )
-// }
 final class TypeMention = TypeMentionImpl;
 
 /** An AST node that mentions a type. */
@@ -33,10 +27,78 @@ abstract private class TypeMentionImpl extends AstNode {
   }
 
   /**
-   * Gets the type mentioned at `path`.
+   * Gets the type mentioned explicitly at `path`.
+   *
+   * This predicate is an internal implementation detail; use `getTypeAt` instead.
    */
   pragma[nomagic]
-  abstract Type getTypeAt(TypePath path);
+  abstract Type getExplicitTypeAt(TypePath path);
+
+  pragma[nomagic]
+  private ClassLikeDeclaration getImplicitEnclosingCand(TypePath path, ParentTypeParameterType tp) {
+    exists(ClassLikeDeclaration nested |
+      nested = this.getExplicitTypeAt(path).(ClassLikeDeclarationType).getClassLikeDeclaration() and
+      tp = TParentTypeParameterType(nested) and
+      not exists(this.getExplicitTypeAt(path.append(TypePath::singleton(tp)))) and
+      result = this.getEnclosingClassResolved+()
+    )
+  }
+
+  /**
+   * Gets the type mentioned at `path`.
+   */
+  Type getTypeAt(TypePath path) {
+    result = this.getExplicitTypeAt(path)
+    or
+    // A mention of a nested type without an explicit qualifier implicitly mentions
+    // the parent type (including at the identifer that introduces the type)
+    //
+    // ```swift
+    // class Outer {
+    //     class Inner {
+    //         let y: Inner // short-hand for `Outer.Inner`
+    //     }
+    // }
+    // ```
+    exists(
+      TypePath prefix, ClassLikeDeclaration parent, ParentTypeParameterType tp, TypePath suffix,
+      ClassLikeDeclaration encl
+    |
+      encl = this.getImplicitEnclosingCand(prefix, tp) and
+      parent = tp.getParent() and
+      path = prefix.append(TypePath::cons(tp, suffix)) and
+      result = encl.getNameNode().(TypeMention).getTypeAt(suffix)
+    |
+      encl = parent
+      or
+      not parent = this.getImplicitEnclosingCand(_, _) and
+      encl.getABaseClass+() = parent
+    )
+    or
+    // A mention of a generic type without explicit type arguments and within
+    // the scope of the type, implicitly mentions all type parameters (including
+    // at the identifer that introduces the type):
+    //
+    // ```swift
+    // class Generic<T> {
+    //     let x: Generic // short-hand for `Generic<T>
+    // }
+    // ```
+    exists(TypePath prefix, ClassLikeDeclarationType t |
+      t = this.getTypeAt(prefix) and
+      forex(TypeParameter tp |
+        tp = t.getATypeParameter() and not tp instanceof ParentTypeParameterType
+      |
+        not exists(this.getExplicitTypeAt(prefix.append(TypePath::singleton(tp))))
+      ) and
+      t.getClassLikeDeclaration() = this.getEnclosingClassResolved+() and
+      result = t.getATypeParameter() and
+      path = prefix.append(TypePath::singleton(result)) and
+      not result instanceof ParentTypeParameterType
+    |
+      isInTypeContextWithImplicitTypeArgs(this) or this = t.getNameNode()
+    )
+  }
 
   /**
    * Gets an explicit qualifier that may refer to the parent type of this nested
@@ -139,7 +201,10 @@ abstract private class ExprTypeMentionImpl extends TypeMentionImpl, Expr {
   pragma[nomagic]
   private ClassLikeDeclaration getQualifierTypeAt(TypePath path) {
     result =
-      this.getParentQualifier().getTypeAt(path).(ClassLikeDeclarationType).getClassLikeDeclaration() and
+      this.getParentQualifier()
+          .getExplicitTypeAt(path)
+          .(ClassLikeDeclarationType)
+          .getClassLikeDeclaration() and
     forall(TypeParameter tp | tp = path.getElement(_) | tp instanceof ParentTypeParameterType)
   }
 
@@ -149,7 +214,7 @@ abstract private class ExprTypeMentionImpl extends TypeMentionImpl, Expr {
     parent = tp.getParent()
   }
 
-  final override Type getTypeAt(TypePath path) {
+  final override Type getExplicitTypeAt(TypePath path) {
     // recursion guard to check that `getType` does not recursively depend on `getTypeAt`
     (exists(this.getType()) implies any()) and
     result = this.getTypeAtImpl(path)
@@ -159,45 +224,8 @@ abstract private class ExprTypeMentionImpl extends TypeMentionImpl, Expr {
       qualifier = this.getParentQualifier() and
       this.isNestedClass(tp, this.getQualifierTypeAt(prefix)) and
       path = TypePath::cons(tp, suffix) and
-      result = qualifier.getTypeAt(prefix.appendInverse(suffix))
+      result = qualifier.getExplicitTypeAt(prefix.appendInverse(suffix))
     )
-    or
-    // A mention of a nested type without an explicit qualifier implicitly mentions
-    // the parent type (including at the identifer that introduces the type)
-    //
-    // ```swift
-    // class Outer {
-    //     class Inner {
-    //         let y: Inner // short-hand for `Outer.Inner`
-    //     }
-    // }
-    // ```
-    exists(
-      ClassLikeDeclaration encl, ClassLikeDeclaration parent, ParentTypeParameterType tp,
-      TypePath suffix
-    |
-      encl = this.getImplicitEnclosingCand(tp) and
-      parent = tp.getParent() and
-      path = TypePath::cons(tp, suffix) and
-      result = encl.getNameNode().(TypeMention).getTypeAt(suffix)
-    |
-      encl = parent
-      or
-      not parent = this.getImplicitEnclosingCand(tp) and
-      encl.getABaseClass+() = parent
-    )
-  }
-
-  pragma[nomagic]
-  private ClassLikeDeclaration getImplicitEnclosingCand(ParentTypeParameterType tp) {
-    not this.hasParentQualifier() and
-    not exists(TypeAliasDeclaration alias |
-      this.getParent*() = alias.getType() //and
-      // not this.getParent*() = any(GenericTypeExpr g).getATypeArgument() and
-      // not this.getParent*() = any(TupleExpr t).getAnElement()
-    ) and
-    tp = TParentTypeParameterType(this.getClassLikeDeclaration()) and
-    result = this.getEnclosingClassResolved+()
   }
 }
 
@@ -216,7 +244,7 @@ class AliasExprTypeMention extends ExprTypeMentionImpl {
   override TypePath getTypeArgumentPath(int i) {
     exists(TypeParameterType tp |
       tp = this.getAliasTypeParameter(i) and
-      tp = alias.getType().(TypeMention).getTypeAt(result)
+      tp = alias.getType().(TypeMention).getExplicitTypeAt(result)
       or
       // `typealias Alias = Generic`, where `Generic` has positional type parameters
       not exists(this.getAliasTypeParameter(_)) and
@@ -247,7 +275,7 @@ class AliasExprTypeMention extends ExprTypeMentionImpl {
   override Type getType() { result = alias.getType().(TypeMention).getType() }
 
   override Type getTypeAtImpl(TypePath path) {
-    result = alias.getType().(TypeMention).getTypeAt(path) and
+    result = alias.getType().(TypeMention).getExplicitTypeAt(path) and
     not result = this.getAliasTypeParameter(_)
   }
 }
@@ -312,7 +340,7 @@ private class NonAliasExprTypeMention extends ExprTypeMentionImpl {
         alias = c.getAMember() and
         alias.getName() = name and
         path = TypePath::cons(baseTp, suffix) and
-        result = alias.getType().(TypeMention).getTypeAt(suffix)
+        result = alias.getType().(TypeMention).getExplicitTypeAt(suffix)
       )
     )
     or
@@ -323,40 +351,21 @@ private class NonAliasExprTypeMention extends ExprTypeMentionImpl {
     |
       exists(int i |
         prefix = Plugin::getFunctionExprParameterTypePath(t, fe.getNumberOfParameters(), i) and
-        result = fe.getParameter(i).getType().(TypeMention).getTypeAt(suffix)
+        result = fe.getParameter(i).getType().(TypeMention).getExplicitTypeAt(suffix)
       )
       or
       prefix = Plugin::getFunctionExprReturnTypePath(t) and
-      result = fe.getReturnType().(TypeMention).getTypeAt(suffix)
+      result = fe.getReturnType().(TypeMention).getExplicitTypeAt(suffix)
     )
     or
     this =
       any(TupleExpr te |
         exists(Plugin::TupleType tt, int i, TypePath suffix |
           tt.getArity() = te.getNumberOfElements() and
-          result = te.getElement(i).getValue().(TypeMention).getTypeAt(suffix) and
+          result = te.getElement(i).getValue().(TypeMention).getExplicitTypeAt(suffix) and
           path = TypePath::cons(tt.getPositionalTypeParameter(i), suffix)
         )
       )
-    or
-    // A mention of a generic type without explicit type arguments and within
-    // the scope of the type, implicitly mentions all type parameters (including
-    // at the identifer that introduces the type):
-    //
-    // ```swift
-    // class Generic<T> {
-    //     let x: Generic // short-hand for `Generic<T>
-    // }
-    // ```
-    not this = any(GenericTypeExpr g).getBase() and
-    exists(ClassLikeDeclarationType rootType |
-      rootType = this.getType() and
-      (isInTypeContextWithImplicitTypeArgs(this) or this = rootType.getNameNode()) and
-      rootType.getClassLikeDeclaration() = this.getEnclosingClassResolved+() and
-      result = rootType.getATypeParameter() and
-      path = TypePath::singleton(result) and
-      not result instanceof ParentTypeParameterType
-    )
   }
 
   override TypeMention resolve() { result = this }
@@ -379,11 +388,11 @@ private class GenericTypeExprTypeMention extends TypeMentionImpl, GenericTypeExp
 
   pragma[nomagic]
   private Type getTypeArgumentAt(int i, TypePath path) {
-    result = this.getTypeArgument(i).(TypeMention).getTypeAt(path)
+    result = this.getTypeArgument(i).(TypeMention).getExplicitTypeAt(path)
   }
 
-  override Type getTypeAt(TypePath path) {
-    result = base.getTypeAt(path)
+  override Type getExplicitTypeAt(TypePath path) {
+    result = base.getExplicitTypeAt(path)
     or
     base = this.getBase() and
     exists(int i, TypePath prefix, TypePath suffix |

unified/ql/test/library-tests/type-inference/nested_types.swift

@@ -107,17 +107,17 @@ class Outer<TOuter> {
     typealias Pair = (Inner<Int>, Inner<Int>)
 
     func f3(p: Pair) {
-        let outer = p.0.getOuter()  // $ target=Outer.Inner.getOuter field=Tuple2.0 $ MISSING: type=outer:TOuter
+        let outer = p.0.getOuter()  // $ target=Outer.Inner.getOuter field=Tuple2.0 type=outer:TOuter
         let inner = p.0.getInner()  // $ target=Outer.Inner.getInner field=Tuple2.0 type=inner:Int
     }
 }
 
 class Foo: Outer<String> {
     func f(x: Pair, y: Outer<Bool>.Pair) {
         var a = x.0.getInner()  // $ target=Outer.Inner.getInner field=Tuple2.0 type=a:Int
-        var b = x.0.getOuter()  // $ target=Outer.Inner.getOuter field=Tuple2.0 $ MISSING: type=b:String
+        var b = x.0.getOuter()  // $ target=Outer.Inner.getOuter field=Tuple2.0 $ MISSING: type=b:String -- this is an instance of variance sub typing
         var c = y.0.getInner()  // $ target=Outer.Inner.getInner field=Tuple2.0 type=c:Int
-        var d = y.0.getOuter()  // $ target=Outer.Inner.getOuter field=Tuple2.0 $ MISSING: type=d:Bool
+        var d = y.0.getOuter()  // $ target=Outer.Inner.getOuter field=Tuple2.0 $ MISSING: type=d:Bool -- this is an instance of variance sub typing
     }
 }