wip8

Author: hvitved

rust/ql/lib/codeql/rust/internal/typeinference/TypeInference.qll

@@ -28,7 +28,7 @@ private newtype TTypeArgumentPosition =
   TMethodTypeArgumentPosition(int pos) {
     exists(any(MethodCallExpr mce).getGenericArgList().getTypeArg(pos))
   } or
-  TTypeParamTypeArgumentPosition(TypeParam tp)
+  TTypeParamTypeArgumentPosition(TypeParameter tp)
 
 private module Input1 implements InputSig1<Location> {
   private import Type as T
@@ -46,46 +46,35 @@ private module Input1 implements InputSig1<Location> {
   class TypeArgumentPosition extends TTypeArgumentPosition {
     int asMethodTypeArgumentPosition() { this = TMethodTypeArgumentPosition(result) }
 
-    TypeParam asTypeParam() { this = TTypeParamTypeArgumentPosition(result) }
+    TypeParameter asTypeParameter() { this = TTypeParamTypeArgumentPosition(result) }
+
+    TypeParam asTypeParam() {
+      result = this.asTypeParameter().(TypeParamTypeParameter).getTypeParam()
+    }
 
     string toString() {
       result = this.asMethodTypeArgumentPosition().toString()
       or
-      result = this.asTypeParam().toString()
+      result = this.asTypeParameter().toString()
     }
   }
 
-  private newtype TTypeParameterPosition =
-    TTypeParamTypeParameterPosition(TypeParam tp) or
-    TImplicitTypeParameterPosition()
+  private newtype TTypeParameterPosition = TTypeParamTypeParameterPosition(TypeParameter tp)
 
   class TypeParameterPosition extends TTypeParameterPosition {
-    TypeParam asTypeParam() { this = TTypeParamTypeParameterPosition(result) }
-
-    /**
-     * Holds if this is the implicit type parameter position used to represent
-     * parameters that are never passed explicitly as arguments.
-     */
-    predicate isImplicit() { this = TImplicitTypeParameterPosition() }
+    TypeParameter asTypeParameter() { this = TTypeParamTypeParameterPosition(result) }
 
-    string toString() {
-      result = this.asTypeParam().toString()
-      or
-      result = "Implicit" and this.isImplicit()
+    TypeParam asTypeParam() {
+      result = this.asTypeParameter().(TypeParamTypeParameter).getTypeParam()
     }
-  }
 
-  /** Holds if `typeParam`, `param` and `ppos` all concern the same `TypeParam`. */
-  additional predicate typeParamMatchPosition(
-    TypeParam typeParam, TypeParamTypeParameter param, TypeParameterPosition ppos
-  ) {
-    typeParam = param.getTypeParam() and typeParam = ppos.asTypeParam()
+    string toString() { result = this.asTypeParameter().toString() }
   }
 
   bindingset[apos]
   bindingset[ppos]
   predicate typeArgumentParameterPositionMatch(TypeArgumentPosition apos, TypeParameterPosition ppos) {
-    apos.asTypeParam() = ppos.asTypeParam()
+    apos.asTypeParameter() = ppos.asTypeParameter()
     or
     apos.asMethodTypeArgumentPosition() = ppos.asTypeParam().getPosition()
   }
@@ -420,8 +409,6 @@ private module Input3 implements InputSig3 {
 
   class CallResolutionContext = FunctionCallMatchingInput::AccessEnvironment;
 
-  class TypePosition = FunctionPosition;
-
   class Callable extends FunctionCallMatchingInput::Declaration {
     TypeMention getAdditionalTypeParameterConstraint(TypeParameter tp) {
       result =
@@ -430,20 +417,39 @@ private module Input3 implements InputSig3 {
             .getAdditionalTypeBound(this.getFunction(), _)
             .getTypeRepr()
     }
+
+    Type getParameterType(int j, TypePath path) {
+      exists(FunctionPosition pos | j = pos.asPosition() | result = this.getDeclaredType(pos, path))
+    }
+
+    Type getReturnType(TypePath path) {
+      exists(FunctionPosition pos | pos.isReturn() | result = this.getDeclaredType(pos, path))
+    }
   }
 
   class Call extends FunctionCallMatchingInput::Access {
     Callable getTarget(string derefChainBorrow) { result = super.getTarget(derefChainBorrow) }
+
+    AstNode getArgument(int i) {
+      exists(FunctionPosition pos |
+        result = this.getNodeAt(pos) and
+        i = pos.asPosition()
+      )
+    }
   }
 
   bindingset[derefChainBorrow]
-  Type inferCallTypeAtPos(Call call, string derefChainBorrow, FunctionPosition pos, TypePath path) {
-    result = call.(FunctionCallMatchingInput::Access).getInferredType(derefChainBorrow, pos, path)
+  Type inferCallArgumentType(Call call, string derefChainBorrow, int i, TypePath path) {
+    exists(FunctionPosition pos |
+      i = pos.asPosition() and
+      result = call.(FunctionCallMatchingInput::Access).getInferredType(derefChainBorrow, pos, path)
+    )
   }
 
   Type inferCallReturnType(AstNode n, TypePath path) {
     exists(Call call, TypePath path0 |
-      result = M3::inferCallReturnType(call, _, n, path0) and
+      result = M3::inferCallReturnType(call, _, path0) and
+      n = call and
       if
         // index expression `x[i]` desugars to `*x.index(i)`, so we must account for
         // the implicit deref
@@ -455,7 +461,7 @@ private module Input3 implements InputSig3 {
 
   Type inferCallArgumentType(AstNode n, TypePath path) {
     exists(FunctionCallMatchingInput::Access call, FunctionPosition pos |
-      result = inferCallArgumentType(call, pos, n, _, _, path) and
+      result = inferCallArgumentType(call, pos.asPosition(), n, _, _, path) and
       not call.(AssocFunctionResolution::AssocFunctionCall).hasReceiverAtPos(pos)
     )
     or
@@ -733,20 +739,22 @@ private class FunctionDeclaration extends Function {
   }
 
   TypeParameter getTypeParameter(ImplOrTraitItemNodeOption i, TypeParameterPosition ppos) {
-    typeParamMatchPosition(this.getTypeParam(i), result, ppos)
-    or
-    // For every `TypeParam` of this function, any associated types accessed on
-    // the type parameter are also type parameters.
-    ppos.isImplicit() and
-    result.(TypeParamAssociatedTypeTypeParameter).getTypeParam() = this.getTypeParam(i)
-    or
-    i = parent and
+    result = ppos.asTypeParameter() and
     (
-      ppos.isImplicit() and result = TSelfTypeParameter(i.asSome())
+      ppos.asTypeParam() = this.getTypeParam(i)
       or
-      ppos.isImplicit() and result.(AssociatedTypeTypeParameter).getTrait() = i.asSome()
+      // For every `TypeParam` of this function, any associated types accessed on
+      // the type parameter are also type parameters.
+      result.(TypeParamAssociatedTypeTypeParameter).getTypeParam() = this.getTypeParam(i)
       or
-      ppos.isImplicit() and this = result.(ImplTraitTypeTypeParameter).getFunction()
+      i = parent and
+      (
+        result = TSelfTypeParameter(i.asSome())
+        or
+        result.(AssociatedTypeTypeParameter).getTrait() = i.asSome()
+        or
+        this = result.(ImplTraitTypeTypeParameter).getFunction()
+      )
     )
   }
 
@@ -810,27 +818,39 @@ private TypePath getPathToImplSelfTypeParam(TypeParam tp) {
 
 pragma[nomagic]
 private Type getCallExprTypeArgument(CallExpr ce, TypeArgumentPosition apos, TypePath path) {
-  exists(Path p, ItemNode resolved, TypeParam tp |
+  exists(Path p, ItemNode resolved, TypeParameter tp |
     p = CallExprImpl::getFunctionPath(ce) and
     resolved = resolvePath(p) and
-    apos.asTypeParam() = tp
+    apos.asTypeParameter() = tp
   |
-    // For type parameters of the function we must resolve their
-    // instantiation from the path. For instance, for `fn bar<A>(a: A) -> A`
-    // and the path `bar<i64>`, we must resolve `A` to `i64`.
-    exists(int i |
-      tp = resolved.getTypeParam(pragma[only_bind_into](i)) and
-      result = getPathTypeArgument(p, pragma[only_bind_into](i)).getTypeAt(path)
+    exists(TypeParam param | param = tp.(TypeParamTypeParameter).getTypeParam() |
+      // For type parameters of the function we must resolve their
+      // instantiation from the path. For instance, for `fn bar<A>(a: A) -> A`
+      // and the path `bar<i64>`, we must resolve `A` to `i64`.
+      exists(int i |
+        param = resolved.getTypeParam(pragma[only_bind_into](i)) and
+        result = getPathTypeArgument(p, pragma[only_bind_into](i)).getTypeAt(path)
+      )
+      or
+      // For type parameters of the `impl` block we must resolve their
+      // instantiation from the path. For instance, for `impl<A> for Foo<A>`
+      // and the path `Foo<i64>::bar` we must resolve `A` to `i64`.
+      exists(ImplItemNode impl, TypePath pathToTp |
+        resolved = impl.getASuccessor(_) and
+        param = impl.getTypeParam(_) and
+        pathToTp = getPathToImplSelfTypeParam(param) and
+        result = p.getQualifier().(TypeMention).getTypeAt(pathToTp.appendInverse(path))
+      )
     )
     or
-    // For type parameters of the `impl` block we must resolve their
-    // instantiation from the path. For instance, for `impl<A> for Foo<A>`
-    // and the path `Foo<i64>::bar` we must resolve `A` to `i64`.
-    exists(ImplItemNode impl, TypePath pathToTp |
-      resolved = impl.getASuccessor(_) and
-      tp = impl.getTypeParam(_) and
-      pathToTp = getPathToImplSelfTypeParam(tp) and
-      result = p.getQualifier().(TypeMention).getTypeAt(pathToTp.appendInverse(path))
+    // In calls like `T::default()` where `T` is a type parameter with a `Default` constraint,
+    // we consider `T` to be an explicit type argument for the implicit `Self` type parameter.
+    exists(TraitItemNode trait, TypeMention qualifier |
+      resolved = trait.getASuccessor(_) and
+      tp = TSelfTypeParameter(trait) and
+      qualifier = p.getQualifier() and
+      result = qualifier.(TypeMention).getTypeAt(path) and
+      not qualifier.(TypeMention).getType() instanceof TraitType
     )
   )
   or
@@ -2833,7 +2853,7 @@ private module FunctionCallMatchingInput implements MatchingWithEnvironmentInput
 
 pragma[nomagic]
 private Type inferCallArgumentType(
-  FunctionCallMatchingInput::Access call, FunctionPosition pos, AstNode n, DerefChain derefChain,
+  FunctionCallMatchingInput::Access call, int pos, AstNode n, DerefChain derefChain,
   BorrowKind borrow, TypePath path
 ) {
   exists(string derefChainBorrow |
@@ -2855,7 +2875,7 @@ private Type inferFunctionCallSelfArgumentType(
 ) {
   exists(FunctionPosition pos, BorrowKind borrow, TypePath path0 |
     call.(AssocFunctionResolution::AssocFunctionCall).hasReceiverAtPos(pos) and
-    result = inferCallArgumentType(call, pos, n, derefChain, borrow, path0)
+    result = inferCallArgumentType(call, pos.asPosition(), n, derefChain, borrow, path0)
   |
     borrow.isNoBorrow() and
     path = path0
@@ -2891,7 +2911,8 @@ private Type inferFunctionCallSelfArgumentType(
 
 abstract private class Constructor extends Addressable {
   final TypeParameter getTypeParameter(TypeParameterPosition ppos) {
-    typeParamMatchPosition(this.getTypeItem().getGenericParamList().getATypeParam(), result, ppos)
+    result = ppos.asTypeParameter() and
+    ppos.asTypeParam() = this.getTypeItem().getGenericParamList().getATypeParam()
   }
 
   abstract TypeItem getTypeItem();

rust/ql/test/library-tests/type-inference/type-inference.expected

@@ -14223,7 +14223,6 @@ inferType
 | pattern_matching.rs:809:13:809:17 | stack | T | {EXTERNAL LOCATION} | i32 |
 | pattern_matching.rs:809:31:809:46 | MacroExpr |  | {EXTERNAL LOCATION} | Vec |
 | pattern_matching.rs:809:31:809:46 | MacroExpr | A | {EXTERNAL LOCATION} | Global |
-| pattern_matching.rs:809:31:809:46 | MacroExpr | T | {EXTERNAL LOCATION} | i32 |
 | pattern_matching.rs:809:36:809:39 | 1i32 |  | {EXTERNAL LOCATION} | i32 |
 | pattern_matching.rs:809:42:809:42 | 2 |  | {EXTERNAL LOCATION} | i32 |
 | pattern_matching.rs:809:45:809:45 | 3 |  | {EXTERNAL LOCATION} | i32 |