wip2

Author: hvitved

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

@@ -425,13 +425,10 @@ private module Input3 implements InputSig3 {
   final class Callable extends FunctionCallMatchingInput::Declaration {
     TypeMention getAdditionalTypeParameterConstraint(TypeParameter tp) {
       result =
-        tp.(TypeParamTypeParameter)
-            .getTypeParam()
-            .getAdditionalTypeBound(this.getFunction(), _)
-            .getTypeRepr()
+        tp.(TypeParamTypeParameter).getTypeParam().getAdditionalTypeBound(this, _).getTypeRepr()
     }
 
-    AstNode getBody() { result = this.getFunction().getBody() }
+    AstNode getBody() { result = super.getBody() }
   }
 
   class Call extends FunctionCallMatchingInput::Access {
@@ -451,6 +448,15 @@ private module Input3 implements InputSig3 {
       call.(FunctionCallMatchingInput::Access).getInferredArgumentType(derefChainBorrow, pos, path)
   }
 
+  Type inferCallReturnType(Call call, TypePath path) {
+    exists(TypePath path0 |
+      result = M3::inferCallReturnTypeDefault(call, _, path0) and
+      // index expression `x[i]` desugars to `*x.index(i)`, so we must account for
+      // the implicit deref
+      if call instanceof IndexExpr then path0.isCons(getRefTypeParameter(_), path) else path = path0
+    )
+  }
+
   Type inferCallArgumentTypeContextual(AstNode n, TypePath path) {
     exists(FunctionCallMatchingInput::Access call, FunctionPosition pos |
       result = inferCallArgumentTypeContextual(call, pos.asPosition(), n, _, _, path) and
@@ -533,9 +539,9 @@ private module Input3 implements InputSig3 {
 
   class Operator extends Callable {
     private Method getSelfOrImpl() {
-      result = f
+      result = this
       or
-      f.implements(result)
+      this.implements(result)
     }
 
     pragma[nomagic]
@@ -580,7 +586,7 @@ private module Input3 implements InputSig3 {
 
     Operator getTarget() {
       exists(ImplOrTraitItemNode i |
-        result.isFunction(this.resolveCallTarget(i, _, _, _), false) // mutual recursion
+        result = this.resolveCallTarget(i, _, _, _) // mutual recursion
       )
     }
   }
@@ -2844,78 +2850,28 @@ private module AssocFunctionResolution {
  * like `foo.bar(baz)` and `Foo::bar(baz)`.
  */
 private module FunctionCallMatchingInput {
-  private newtype TDeclaration =
-    TFunctionDeclaration(FunctionDeclaration f, boolean forIndexExpr) {
-      (
-        forIndexExpr = false
-        or
-        forIndexExpr = true and
-        exists(Function traitFunction |
-          traitFunction =
-            [any(IndexTrait t).getIndexFunction(), any(IndexMutTrait t).getIndexMutFunction()]
-        |
-          f = traitFunction
-          or
-          f.implements(traitFunction)
-        )
-      )
-    }
-
-  final class Declaration extends TFunctionDeclaration {
-    FunctionDeclaration f;
-    boolean forIndexExpr;
-
-    Declaration() { this = TFunctionDeclaration(f, forIndexExpr) }
-
-    FunctionDeclaration getFunction() { result = f }
-
-    // predicate isFunction(ImplOrTraitItemNodeOption i_, Function f_) {
-    //   i_ = i and
-    //   f_ = f
-    // }
-    predicate isFunction(Function f_, boolean forIndexExpr_) {
-      f_ = f and
-      forIndexExpr_ = forIndexExpr
-    }
-
+  final class Declaration extends FunctionDeclaration {
     TypeParameter getTypeParameter(TypeParameterPosition ppos) {
-      exists(ImplOrTraitItemNodeOption i | result = f.getTypeParameter(i, ppos) |
+      exists(ImplOrTraitItemNodeOption i | result = this.getTypeParameter(i, ppos) |
         i.isNone()
         or
-        i.asSome().getAnAssocItem() = f
+        i.asSome().getAnAssocItem() = this
       )
     }
 
     Type getParameterType(int j, TypePath path) {
       exists(FunctionPosition fpos | j = fpos.asPosition() |
-        result = fpos.getTypeMention(f).getTypeAt(path)
+        result = fpos.getTypeMention(this).getTypeAt(path)
       )
     }
 
-    Type getReturnType(TypePath path) {
-      // index expression `x[i]` desugars to `*x.index(i)`, so we must account for
-      // the implicit deref
-      exists(TypePath path0 | result = f.getReturnType2(path0) |
-        forIndexExpr = true and
-        path0.isCons(getRefTypeParameter(_), path)
-        or
-        forIndexExpr = false and
-        path = path0
-      )
-    }
-
-    string toString() { result = f.toString() }
-
-    Location getLocation() { result = f.getLocation() }
+    Type getReturnType(TypePath path) { result = this.getReturnType2(path) }
   }
 
   pragma[nomagic]
   private TypeMention getAdditionalTypeParameterConstraint(TypeParameter tp, Declaration decl) {
     result =
-      tp.(TypeParamTypeParameter)
-          .getTypeParam()
-          .getAdditionalTypeBound(decl.getFunction(), _)
-          .getTypeRepr()
+      tp.(TypeParamTypeParameter).getTypeParam().getAdditionalTypeBound(decl, _).getTypeRepr()
   }
 
   bindingset[decl]
@@ -3024,10 +2980,7 @@ private module FunctionCallMatchingInput {
     }
 
     override Declaration getTarget(string derefChainBorrow) {
-      exists(ImplOrTraitItemNode i, boolean forIndexExpr |
-        result.isFunction(this.getTarget(i, derefChainBorrow), forIndexExpr) and
-        if this instanceof IndexExpr then forIndexExpr = true else forIndexExpr = false
-      )
+      exists(ImplOrTraitItemNode i | result = this.getTarget(i, derefChainBorrow))
     }
 
     pragma[nomagic]
@@ -3080,9 +3033,7 @@ private module FunctionCallMatchingInput {
     }
 
     pragma[nomagic]
-    private Declaration getTarget() {
-      result = TFunctionDeclaration(super.resolveCallTargetViaPathResolution(), false)
-    }
+    private Declaration getTarget() { result = super.resolveCallTargetViaPathResolution() }
 
     override Declaration getTarget(string derefChainBorrow) {
       result = this.getTarget() and

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

@@ -2282,6 +2282,11 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
         exists(ctx)
       }
 
+      /**
+       * TODO
+       */
+      Type inferCallReturnType(Call call, TypePath path);
+
       /**
        * Gets the contextually inferred type of call argument `n` at `path`. The context
        * used is the target of the call, for example in
@@ -2852,7 +2857,7 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
         or
         result = inferTypeFromStep(n, path)
         or
-        result = inferCallReturnType(n, _, path)
+        result = inferCallReturnType(n, path)
         or
         result = inferMemberAccessType(n, path)
         or
@@ -2985,7 +2990,7 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
       private module CallMatching = MatchingWithEnvironment<CallMatchingInput>;
 
       pragma[nomagic]
-      private Type inferCallReturnType(Call call, CallResolutionContext ctx, TypePath path) {
+      Type inferCallReturnTypeDefault(Call call, CallResolutionContext ctx, TypePath path) {
         result =
           CallMatching::inferAccessType(call, ctx, CallMatchingInput::getReturnPosition(), path)
       }