wip

Author: hvitved

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

@@ -298,14 +298,17 @@ private class FunctionDeclaration extends Function {
   }
 
   pragma[nomagic]
-  Type getParameterType(ImplOrTraitItemNodeOption i, FunctionPosition pos, TypePath path) {
+  Type getParameterType(ImplOrTraitItemNodeOption i, FunctionPosition posAdj, TypePath path) {
     i = parent and
     (
-      not pos.isReturn() and
-      result = getAssocFunctionTypeAt(this, i.asSome(), pos, path)
+      exists(FunctionPosition pos |
+        not pos.isReturn() and
+        result = getAssocFunctionTypeAt(this, i.asSome(), pos, path) and
+        posAdj = pos.getFunctionCallAdjusted(this)
+      )
       or
       i.isNone() and
-      result = this.getParam(pos.asPosition()).getTypeRepr().(TypeMention).getTypeAt(path)
+      result = this.getParam(posAdj.asPosition()).getTypeRepr().(TypeMention).getTypeAt(path)
     )
   }
 
@@ -1555,32 +1558,6 @@ private module AssocFunctionResolution {
     AssocFunctionTraitIsVisible::traitIsVisible(afc, impl.resolveTraitTy())
   }
 
-  private Type getNonTypeParameterTypeQualifier(AssocFunctionCall afc) {
-    result = getCallExprTypeQualifier(afc, TypePath::nil(), _) and
-    not result instanceof TypeParameter
-  }
-
-  pragma[nomagic]
-  private predicate callInfo(
-    AssocFunctionCall afc, string name, int arity, TypeOption typeQualifier,
-    TypeOption traitQualifier, boolean hasReceiver
-  ) {
-    afc.hasNameAndArity(name, arity) and
-    (if afc.hasReceiver() then hasReceiver = true else hasReceiver = false) and
-    (
-      typeQualifier.asSome() = getNonTypeParameterTypeQualifier(afc)
-      or
-      not exists(getNonTypeParameterTypeQualifier(afc)) and
-      typeQualifier.isNone()
-    ) and
-    (
-      traitQualifier.asSome() = TTrait(afc.getATrait())
-      or
-      not afc.hasATrait() and
-      traitQualifier.isNone()
-    )
-  }
-
   bindingset[implType, trait, isMethod]
   private predicate callMatching(
     TypeOption implType, TypeOption trait, boolean isMethod, TypeOption typeQualifier,
@@ -1641,7 +1618,7 @@ private module AssocFunctionResolution {
       string name, int arity, TypeOption typeQualifier, TypeOption traitQualifier,
       boolean hasReceiver
     |
-      callInfo(afc, name, arity, typeQualifier, traitQualifier, hasReceiver) and
+      afc.hasSyntacticInfo(name, arity, typeQualifier, traitQualifier, hasReceiver) and
       if not afc.hasATrait() and i.(Impl).hasTrait()
       then callVisibleImplTraitCandidate(afc, i)
       else any()
@@ -1686,14 +1663,19 @@ private module AssocFunctionResolution {
     AssocFunctionType self, TypePath blanketPath, TypeParam blanketTypeParam
   ) {
     exists(string name, int arity, TypeOption traitQualifier, boolean hasReceiver |
-      callInfo(afc, name, arity, _, traitQualifier, hasReceiver) and
+      afc.hasSyntacticInfo(name, arity, _, traitQualifier, hasReceiver) and
       assocFunctionSelfInfoBlanketLikeCand(f, name, arity, selfPosAdj, impl, self, blanketPath,
         blanketTypeParam, traitQualifier, hasReceiver)
     |
       if not afc.hasATrait() then callVisibleImplTraitCandidate(afc, impl) else any()
     )
   }
 
+  private Type getNonTypeParameterTypeQualifier(AssocFunctionCall afc) {
+    result = getCallExprTypeQualifier(afc, TypePath::nil(), _) and
+    not result instanceof TypeParameter
+  }
+
   /**
    * A (potential) call to an associated function.
    *
@@ -1746,6 +1728,31 @@ private module AssocFunctionResolution {
 
     predicate hasATrait() { exists(this.getATrait()) }
 
+    /**
+     * Holds if this call has the given purely syntactic information, that is,
+     * information that does not rely on type inference.
+     */
+    pragma[nomagic]
+    predicate hasSyntacticInfo(
+      string name, int arity, TypeOption typeQualifier, TypeOption traitQualifier,
+      boolean hasReceiver
+    ) {
+      this.hasNameAndArity(name, arity) and
+      (if this.hasReceiver() then hasReceiver = true else hasReceiver = false) and
+      (
+        typeQualifier.asSome() = getNonTypeParameterTypeQualifier(this)
+        or
+        not exists(getNonTypeParameterTypeQualifier(this)) and
+        typeQualifier.isNone()
+      ) and
+      (
+        traitQualifier.asSome() = TTrait(this.getATrait())
+        or
+        not this.hasATrait() and
+        traitQualifier.isNone()
+      )
+    }
+
     Type getTypeAt(FunctionPosition posAdj, TypePath path) {
       result = inferType(this.getNodeAt(posAdj), path)
     }
@@ -2420,7 +2427,7 @@ private module AssocFunctionResolution {
         or
         selfPosAdj_.asPosition() = 0 and hasReceiver = true
       |
-        callInfo(afc_, name, arity, typeQualifier, traitQualifier, _) and
+        afc_.hasSyntacticInfo(name, arity, typeQualifier, traitQualifier, _) and
         this.hasSignature(_, selfPosAdj_, strippedTypePath, strippedType, name, arity) and
         forall(Impl i |
           i.isInherent() and
@@ -2718,7 +2725,7 @@ private module AssocFunctionResolution {
 
 /**
  * A matching configuration for resolving types of function call expressions
- * like `foo.bar(baz)`.
+ * like `foo.bar(baz)` and `Foo::bar(baz)`.
  */
 private module FunctionCallMatchingInput implements MatchingWithEnvironmentInputSig {
   import FunctionPositionMatchingInput
@@ -2741,10 +2748,10 @@ private module FunctionCallMatchingInput implements MatchingWithEnvironmentInput
       result = f.getTypeParameter(i, ppos)
     }
 
-    Type getDeclaredType(DeclarationPosition dpos, TypePath path) {
-      result = f.getParameterType(i, dpos, path)
+    Type getDeclaredType(FunctionPosition posAdj, TypePath path) {
+      result = f.getParameterType(i, posAdj, path)
       or
-      dpos.isReturn() and
+      posAdj.isReturn() and
       result = f.getReturnType(i, path)
     }
 
@@ -2816,25 +2823,25 @@ private module FunctionCallMatchingInput implements MatchingWithEnvironmentInput
     }
 
     pragma[nomagic]
-    private Type getInferredSelfType(FunctionPosition pos, string derefChainBorrow, TypePath path) {
+    private Type getInferredSelfType(FunctionPosition posAdj, string derefChainBorrow, TypePath path) {
       exists(DerefChain derefChain, BorrowKind borrow |
-        result = super.getSelfTypeAt(pos.getFunctionCallAdjusted(), derefChain, borrow, path) and
+        result = super.getSelfTypeAt(posAdj, derefChain, borrow, path) and
         derefChainBorrow = encodeDerefChainBorrow(derefChain, borrow) and
-        pos.isSelf()
+        super.hasReceiverPos(posAdj)
       )
     }
 
     pragma[nomagic]
-    private Type getInferredNonSelfType(FunctionPosition pos, TypePath path) {
-      result = super.getTypeAt(pos.getFunctionCallAdjusted(), path) and
-      not pos.isSelf()
+    private Type getInferredNonSelfType(FunctionPosition posAdj, TypePath path) {
+      result = super.getTypeAt(posAdj, path) and
+      not super.hasReceiverPos(posAdj)
     }
 
     bindingset[derefChainBorrow]
-    override Type getInferredType(string derefChainBorrow, FunctionPosition pos, TypePath path) {
-      result = this.getInferredSelfType(pos, derefChainBorrow, path)
+    override Type getInferredType(string derefChainBorrow, FunctionPosition posAdj, TypePath path) {
+      result = this.getInferredSelfType(posAdj, derefChainBorrow, path)
       or
-      result = this.getInferredNonSelfType(pos, path)
+      result = this.getInferredNonSelfType(posAdj, path)
     }
 
     Method getTarget(ImplOrTraitItemNode i, string derefChainBorrow) {
@@ -2882,24 +2889,22 @@ private module FunctionCallMatching = MatchingWithEnvironment<FunctionCallMatchi
 
 pragma[nomagic]
 private Type inferFunctionCallType0(
-  FunctionCallMatchingInput::Access a, FunctionCallMatchingInput::AccessPosition apos, AstNode n,
-  DerefChain derefChain, BorrowKind borrow, TypePath path
+  FunctionCallMatchingInput::Access a, FunctionPosition posAdj, AstNode n, DerefChain derefChain,
+  BorrowKind borrow, TypePath path
 ) {
   exists(TypePath path0 |
-    exists(FunctionPosition posAdj |
-      n = a.getNodeAt(posAdj) and
-      posAdj = apos.getFunctionCallAdjusted()
-    |
+    n = a.getNodeAt(posAdj) and
+    (
       exists(string derefChainBorrow |
         FunctionCallMatchingInput::decodeDerefChainBorrow(derefChainBorrow, derefChain, borrow)
       |
-        result = FunctionCallMatching::inferAccessType(a, derefChainBorrow, apos, path0)
+        result = FunctionCallMatching::inferAccessType(a, derefChainBorrow, posAdj, path0)
         or
-        a.hasUnknownTypeAt(derefChainBorrow, apos, path0) and
+        a.hasUnknownTypeAt(derefChainBorrow, posAdj, path0) and
         result = TUnknownType()
       )
       or
-      a.hasUnknownTypeAt(apos, path0) and
+      a.hasUnknownTypeAt(posAdj, path0) and
       result = TUnknownType() and
       derefChain.isEmpty() and
       borrow.isNoBorrow()
@@ -2908,7 +2913,7 @@ private Type inferFunctionCallType0(
     if
       // index expression `x[i]` desugars to `*x.index(i)`, so we must account for
       // the implicit deref
-      apos.isReturn() and
+      posAdj.isReturn() and
       a instanceof IndexExpr
     then path0.isCons(getRefTypeParameter(_), path)
     else path = path0
@@ -2917,8 +2922,10 @@ private Type inferFunctionCallType0(
 
 pragma[nomagic]
 private Type inferFunctionCallTypeNonSelf(AstNode n, FunctionPosition pos, TypePath path) {
-  result = inferFunctionCallType0(_, pos, n, _, _, path) and
-  not pos.isSelf()
+  exists(FunctionCallMatchingInput::Access a |
+    result = inferFunctionCallType0(a, pos, n, _, _, path) and
+    not a.(AssocFunctionResolution::AssocFunctionCall).hasReceiverPos(pos)
+  )
 }
 
 /**
@@ -2929,11 +2936,13 @@ private Type inferFunctionCallTypeNonSelf(AstNode n, FunctionPosition pos, TypeP
  * empty, at which point the inferred type can be applied back to `n`.
  */
 pragma[nomagic]
-private Type inferMethodCallTypeSelf(MethodCall mc, AstNode n, DerefChain derefChain, TypePath path) {
-  exists(FunctionCallMatchingInput::AccessPosition apos, BorrowKind borrow, TypePath path0 |
-    result = inferFunctionCallType0(mc, apos, n, derefChain, borrow, path0) and
-    apos.isSelf()
+private Type inferFunctionCallTypeSelf(
+  MethodCall mc, AstNode n, DerefChain derefChain, TypePath path
+) {
+  exists(FunctionPosition posAdj, BorrowKind borrow, TypePath path0 |
+    result = inferFunctionCallType0(mc, posAdj, n, derefChain, borrow, path0) //and
   |
+    posAdj.asPosition() = 0 and
     borrow.isNoBorrow() and
     path = path0
     or
@@ -2949,7 +2958,7 @@ private Type inferMethodCallTypeSelf(MethodCall mc, AstNode n, DerefChain derefC
     DerefChain derefChain0, Type t0, TypePath path0, DerefImplItemNode impl, Type selfParamType,
     TypePath selfPath
   |
-    t0 = inferMethodCallTypeSelf(mc, n, derefChain0, path0) and
+    t0 = inferFunctionCallTypeSelf(mc, n, derefChain0, path0) and
     derefChain0.isCons(impl, derefChain) and
     selfParamType = impl.resolveSelfTypeAt(selfPath)
   |
@@ -2966,21 +2975,29 @@ private Type inferMethodCallTypeSelf(MethodCall mc, AstNode n, DerefChain derefC
   )
 }
 
-private Type inferMethodCallTypePreCheck(AstNode n, FunctionPosition pos, TypePath path) {
+private Type inferFunctionCallTypePreCheck(AstNode n, FunctionPosition pos, TypePath path) {
   result = inferFunctionCallTypeNonSelf(n, pos, path)
   or
-  exists(MethodCall mc |
-    result = inferMethodCallTypeSelf(mc, n, DerefChain::nil(), path) and
-    if mc instanceof CallExpr then pos.asPosition() = 0 else pos.isSelf()
+  exists(FunctionCallMatchingInput::Access a |
+    result = inferFunctionCallTypeSelf(a, n, DerefChain::nil(), path) and
+    if a.(AssocFunctionResolution::AssocFunctionCall).hasReceiver()
+    then pos.isSelf()
+    else pos.asPosition() = 0
   )
+  // result = inferFunctionCallTypeNonSelf(n, pos, path)
+  // or
+  // exists(MethodCall mc |
+  //   result = inferMethodCallTypeSelf(mc, n, DerefChain::nil(), path) and
+  //   if mc instanceof CallExpr then pos.asPosition() = 0 else pos.isSelf()
+  // )
 }
 
 /**
  * Gets the type of `n` at `path`, where `n` is either a method call or an
  * argument/receiver of a method call.
  */
-private predicate inferMethodCallType =
-  ContextTyping::CheckContextTyping<inferMethodCallTypePreCheck/3>::check/2;
+private predicate inferFunctionCallType =
+  ContextTyping::CheckContextTyping<inferFunctionCallTypePreCheck/3>::check/2;
 
 abstract private class TupleLikeConstructor extends Addressable {
   final TypeParameter getTypeParameter(TypeParameterPosition ppos) {
@@ -3218,14 +3235,14 @@ private module OperationMatchingInput implements MatchingInputSig {
     }
 
     pragma[nomagic]
-    private predicate borrowsAt(DeclarationPosition pos) {
+    private predicate borrowsAt(FunctionPosition posAdj) {
       exists(TraitItemNode t, string path, string method |
         this.getSelfOrImpl() = t.getAssocItem(method) and
         path = t.getCanonicalPath(_) and
         exists(int borrows | OperationImpl::isOverloaded(_, _, path, method, borrows) |
-          pos.isSelf() and borrows >= 1
+          posAdj.asPosition() = 0 and borrows >= 1
           or
-          pos.asPosition() = 0 and
+          posAdj.asPosition() = 1 and
           borrows >= 2
         )
       )
@@ -3234,13 +3251,13 @@ private module OperationMatchingInput implements MatchingInputSig {
     pragma[nomagic]
     private predicate derefsReturn() { this.getSelfOrImpl() = any(DerefTrait t).getDerefFunction() }
 
-    Type getDeclaredType(DeclarationPosition dpos, TypePath path) {
+    Type getDeclaredType(FunctionPosition posAdj, TypePath path) {
       exists(TypePath path0 |
-        result = super.getDeclaredType(dpos, path0) and
+        result = super.getDeclaredType(posAdj, path0) and
         if
-          this.borrowsAt(dpos)
+          this.borrowsAt(posAdj)
           or
-          dpos.isReturn() and this.derefsReturn()
+          posAdj.isReturn() and this.derefsReturn()
         then path0.isCons(getRefTypeParameter(_), path)
         else path0 = path
       )
@@ -3251,8 +3268,8 @@ private module OperationMatchingInput implements MatchingInputSig {
     Type getTypeArgument(TypeArgumentPosition apos, TypePath path) { none() }
 
     pragma[nomagic]
-    Type getInferredType(FunctionPosition pos, TypePath path) {
-      result = inferType(this.getNodeAt(pos.getFunctionCallAdjusted()), path)
+    Type getInferredType(FunctionPosition posAdj, TypePath path) {
+      result = inferType(this.getNodeAt(posAdj), path)
     }
 
     Declaration getTarget() {
@@ -3270,7 +3287,7 @@ private Type inferOperationType0(AstNode n, FunctionPosition pos, TypePath path)
   exists(OperationMatchingInput::Access a, FunctionPosition posAdj |
     n = a.getNodeAt(posAdj) and
     posAdj = pos.getFunctionCallAdjusted() and
-    result = OperationMatching::inferAccessType(a, pos, path)
+    result = OperationMatching::inferAccessType(a, posAdj, path)
   )
 }
 
@@ -4091,7 +4108,7 @@ private module Cached {
       or
       result = inferStructExprType(n, path)
       or
-      result = inferMethodCallType(n, path)
+      result = inferFunctionCallType(n, path)
       or
       result = inferNonMethodCallType(n, path)
       or
@@ -4134,8 +4151,8 @@ private module Debug {
   Locatable getRelevantLocatable() {
     exists(string filepath, int startline, int startcolumn, int endline, int endcolumn |
       result.getLocation().hasLocationInfo(filepath, startline, startcolumn, endline, endcolumn) and
-      filepath.matches("%/overloading.rs") and
-      startline = 399
+      filepath.matches("%/main.rs") and
+      startline = 2050
     )
   }
 
@@ -4161,9 +4178,9 @@ private module Debug {
     t = self.getTypeAt(path)
   }
 
-  predicate debugInferMethodCallType(AstNode n, TypePath path, Type t) {
+  predicate debugInferFunctionCallType(AstNode n, TypePath path, Type t) {
     n = getRelevantLocatable() and
-    t = inferMethodCallType(n, path)
+    t = inferFunctionCallType(n, path)
   }
 
   predicate debugInferNonMethodCallType(AstNode n, TypePath path, Type t) {