wip

Author: hvitved

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

@@ -2844,15 +2844,15 @@ private module FunctionCallMatchingInput implements MatchingWithEnvironmentInput
       result = this.getInferredNonSelfType(posAdj, path)
     }
 
-    Method getTarget(ImplOrTraitItemNode i, string derefChainBorrow) {
+    private AssocFunction getTarget(ImplOrTraitItemNode i, string derefChainBorrow) {
       exists(DerefChain derefChain, BorrowKind borrow |
         derefChainBorrow = encodeDerefChainBorrow(derefChain, borrow) and
         result = super.resolveCallTarget(i, derefChain, borrow) // mutual recursion; resolving method calls requires resolving types and vice versa
       )
     }
 
     override Declaration getTarget(string derefChainBorrow) {
-      exists(ImplOrTraitItemNodeOption i, Function f |
+      exists(ImplOrTraitItemNodeOption i, AssocFunction f |
         f = this.getTarget(i.asSome(), derefChainBorrow) and
         result = TFunctionDeclaration(i, f)
       )
@@ -2883,6 +2883,78 @@ private module FunctionCallMatchingInput implements MatchingWithEnvironmentInput
       )
     }
   }
+
+  private class NonAssocCallExprAccess extends Access, CallExpr, ContextTyping::ContextTypedCallCand
+  {
+    NonAssocCallExprAccess() {
+      forex(ItemNode i | i = CallExprImpl::getResolvedFunction(this) |
+        not i instanceof AssocFunction
+      )
+    }
+
+    pragma[nomagic]
+    override Type getTypeArgument(TypeArgumentPosition apos, TypePath path) {
+      result = getCallExprTypeArgument(this, apos, path)
+    }
+
+    override AstNode getNodeAt(FunctionPosition pos) {
+      result = this.getSyntacticArgument(pos.asArgumentPosition())
+      or
+      result = this and pos.isReturn()
+    }
+
+    pragma[nomagic]
+    private Type getInferredType(AccessPosition apos, TypePath path) {
+      apos.isTypeQualifier() and
+      result = getCallExprTypeQualifier(this, path, false)
+      or
+      result = inferType(this.getNodeAt(apos), path)
+    }
+
+    bindingset[derefChainBorrow]
+    override Type getInferredType(string derefChainBorrow, FunctionPosition posAdj, TypePath path) {
+      exists(derefChainBorrow) and
+      result = this.getInferredType(posAdj, path)
+    }
+
+    pragma[nomagic]
+    private FunctionDeclaration resolveCallTargetViaPathResolution() {
+      result = CallExprImpl::getResolvedFunction(this)
+    }
+
+    private Declaration getTarget() {
+      exists(ImplOrTraitItemNodeOption i, FunctionDeclaration f |
+        f = this.resolveCallTargetViaPathResolution() and
+        f.isDirectlyFor(i) and
+        result = TFunctionDeclaration(i, f)
+      )
+    }
+
+    override Declaration getTarget(string derefChainBorrow) {
+      exists(DerefChain derefChain, BorrowKind borrow |
+        result = this.getTarget() and
+        derefChain.isEmpty() and
+        borrow.isNoBorrow() and
+        derefChainBorrow = encodeDerefChainBorrow(derefChain, borrow)
+      )
+    }
+
+    override predicate hasUnknownTypeAt(string derefChainBorrow, FunctionPosition pos, TypePath path) {
+      none()
+    }
+
+    /**
+     * Holds if the return type of this call at `path` may have to be inferred
+     * from the context.
+     */
+    pragma[nomagic]
+    override predicate hasUnknownTypeAt(FunctionPosition pos, TypePath path) {
+      exists(ImplOrTraitItemNodeOption i, FunctionDeclaration f |
+        TFunctionDeclaration(i, f) = this.getTarget() and
+        this.hasUnknownTypeAt(i.asSome(), f, pos, path)
+      )
+    }
+  }
 }
 
 private module FunctionCallMatching = MatchingWithEnvironment<FunctionCallMatchingInput>;
@@ -2984,12 +3056,6 @@ private Type inferFunctionCallTypePreCheck(AstNode n, FunctionPosition pos, Type
     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()
-  // )
 }
 
 /**
@@ -3054,16 +3120,10 @@ private class TupleLikeVariant extends TupleLikeConstructor instanceof Variant {
  * This also includes "calls" to tuple variants and tuple structs such
  * as `Result::Ok(42)`.
  */
-private module NonMethodCallMatchingInput implements MatchingInputSig {
+private module TupleLikeConstructionMatchingInput implements MatchingInputSig {
   import FunctionPositionMatchingInput
 
-  private class NonMethodFunctionDeclaration extends NonMethodFunction, FunctionDeclaration { }
-
-  private newtype TDeclaration =
-    TNonMethodFunctionDeclaration(ImplOrTraitItemNodeOption i, NonMethodFunctionDeclaration f) {
-      f.isFor(i)
-    } or
-    TTupleLikeConstructorDeclaration(TupleLikeConstructor tc)
+  private newtype TDeclaration = TTupleLikeConstructorDeclaration(TupleLikeConstructor tc)
 
   abstract class Declaration extends TDeclaration {
     abstract TypeParameter getTypeParameter(TypeParameterPosition ppos);
@@ -3085,31 +3145,6 @@ private module NonMethodCallMatchingInput implements MatchingInputSig {
     abstract Location getLocation();
   }
 
-  private class NonMethodFunctionDecl extends Declaration, TNonMethodFunctionDeclaration {
-    private ImplOrTraitItemNodeOption i;
-    private NonMethodFunctionDeclaration f;
-
-    NonMethodFunctionDecl() { this = TNonMethodFunctionDeclaration(i, f) }
-
-    override TypeParameter getTypeParameter(TypeParameterPosition ppos) {
-      result = f.getTypeParameter(i, ppos)
-    }
-
-    override Type getParameterType(DeclarationPosition dpos, TypePath path) {
-      result = f.getParameterType(i, dpos, path)
-    }
-
-    override Type getReturnType(TypePath path) { result = f.getReturnType(i, path) }
-
-    override string toString() {
-      i.isNone() and result = f.toString()
-      or
-      result = f.toStringExt(i.asSome())
-    }
-
-    override Location getLocation() { result = f.getLocation() }
-  }
-
   private class TupleLikeConstructorDeclaration extends Declaration,
     TTupleLikeConstructorDeclaration
   {
@@ -3164,15 +3199,6 @@ private module NonMethodCallMatchingInput implements MatchingInputSig {
 
     pragma[inline]
     Declaration getTarget() {
-      exists(ImplOrTraitItemNodeOption i, NonMethodFunctionDeclaration f |
-        result = TNonMethodFunctionDeclaration(i, f)
-      |
-        f = this.(AssocFunctionResolution::AssocFunctionCall).resolveCallTarget(i.asSome(), _, _) // mutual recursion; resolving some associated function calls requires resolving types
-        or
-        f = this.resolveCallTargetViaPathResolution() and
-        f.isDirectlyFor(i)
-      )
-      or
       exists(ItemNode i | i = this.resolveCallTargetViaPathResolution() |
         result = TTupleLikeConstructorDeclaration(i)
       )
@@ -3184,11 +3210,6 @@ private module NonMethodCallMatchingInput implements MatchingInputSig {
      */
     pragma[nomagic]
     predicate hasUnknownTypeAt(FunctionPosition pos, TypePath path) {
-      exists(ImplOrTraitItemNodeOption i, NonMethodFunctionDeclaration f |
-        TNonMethodFunctionDeclaration(i, f) = this.getTarget() and
-        this.hasUnknownTypeAt(i.asSome(), f, pos, path)
-      )
-      or
       // Tuple declarations, such as `Result::Ok(...)`, may also be context typed
       exists(TupleLikeConstructor tc, TypeParameter tp |
         tc = this.resolveCallTargetViaPathResolution() and
@@ -3205,20 +3226,20 @@ private module NonMethodCallMatchingInput implements MatchingInputSig {
   }
 }
 
-private module NonMethodCallMatching = Matching<NonMethodCallMatchingInput>;
+private module TupleLikeConstructionMatching = Matching<TupleLikeConstructionMatchingInput>;
 
 pragma[nomagic]
-private Type inferNonMethodCallType0(AstNode n, FunctionPosition pos, TypePath path) {
-  exists(NonMethodCallMatchingInput::Access a | n = a.getNodeAt(pos) |
-    result = NonMethodCallMatching::inferAccessType(a, pos, path)
+private Type inferTupleLikeConstructionType0(AstNode n, FunctionPosition pos, TypePath path) {
+  exists(TupleLikeConstructionMatchingInput::Access a | n = a.getNodeAt(pos) |
+    result = TupleLikeConstructionMatching::inferAccessType(a, pos, path)
     or
     a.hasUnknownTypeAt(pos, path) and
     result = TUnknownType()
   )
 }
 
-private predicate inferNonMethodCallType =
-  ContextTyping::CheckContextTyping<inferNonMethodCallType0/3>::check/2;
+private predicate inferTupleLikeConstructionType =
+  ContextTyping::CheckContextTyping<inferTupleLikeConstructionType0/3>::check/2;
 
 /**
  * A matching configuration for resolving types of operations like `a + b`.
@@ -4110,7 +4131,7 @@ private module Cached {
       or
       result = inferFunctionCallType(n, path)
       or
-      result = inferNonMethodCallType(n, path)
+      result = inferTupleLikeConstructionType(n, path)
       or
       result = inferOperationType(n, path)
       or
@@ -4152,7 +4173,7 @@ private module Debug {
     exists(string filepath, int startline, int startcolumn, int endline, int endcolumn |
       result.getLocation().hasLocationInfo(filepath, startline, startcolumn, endline, endcolumn) and
       filepath.matches("%/main.rs") and
-      startline = 2050
+      startline = 661
     )
   }
 
@@ -4183,9 +4204,9 @@ private module Debug {
     t = inferFunctionCallType(n, path)
   }
 
-  predicate debugInferNonMethodCallType(AstNode n, TypePath path, Type t) {
+  predicate debugInferTupleLikeConstructionType(AstNode n, TypePath path, Type t) {
     n = getRelevantLocatable() and
-    t = inferNonMethodCallType(n, path)
+    t = inferTupleLikeConstructionType(n, path)
   }
 
   predicate debugTypeMention(TypeMention tm, TypePath path, Type type) {