dbg

Author: hvitved

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

@@ -420,17 +420,63 @@ private module Input3 implements InputSig3 {
     override AstNode getInitializer() { result = LetStmt.super.getInitializer() }
   }
 
-  class CallResolutionContext = FunctionCallMatchingInput::AccessEnvironment;
+  abstract class Parameter extends Rust::ParamBase {
+    abstract AstNode getPattern();
+
+    abstract TypeMention getType();
+  }
+
+  private class SelfParamParameter extends Parameter, SelfParam {
+    override AstNode getPattern() { result = this }
+
+    override TypeMention getType() { result = getSelfParamTypeMention(this) }
+  }
+
+  private class ParamParameter extends Parameter, Param {
+    override AstNode getPattern() { result = this.getPat() }
+
+    override TypeMention getType() { result = this.getTypeRepr() }
+  }
+
+  final class Callable extends Rust::Callable {
+    TypeParameter getTypeParameter(TypeParameterPosition ppos) {
+      result = this.(FunctionDeclaration).getTypeParameter(ppos)
+    }
 
-  final class Callable extends FunctionCallMatchingInput::Declaration {
     TypeMention getAdditionalTypeParameterConstraint(TypeParameter tp) {
       result =
         tp.(TypeParamTypeParameter).getTypeParam().getAdditionalTypeBound(this, _).getTypeRepr()
     }
 
+    Parameter getParameter(int i) {
+      i = 0 and
+      result = this.getSelfParam()
+      or
+      exists(int pos | result = this.getParam(pos) |
+        if this instanceof Method then i = pos + 1 else i = pos
+      )
+    }
+
+    TypeMention getReturnType() { result = getReturnTypeMention(this) }
+
     AstNode getBody() { result = super.getBody() }
   }
 
+  Type getCallableReturnType(Callable c, TypePath path) {
+    if c.(Function).isAsync()
+    then
+      path.isEmpty() and
+      result = getFutureTraitType()
+      or
+      exists(TypePath suffix |
+        result = getReturnTypeMention(c).getTypeAt(suffix) and
+        path = TypePath::cons(getDynFutureOutputTypeParameter(), suffix)
+      )
+    else result = getReturnTypeMention(c).getTypeAt(path)
+  }
+
+  class CallResolutionContext = FunctionCallMatchingInput::AccessEnvironment;
+
   class Call extends FunctionCallMatchingInput::Access {
     Callable getTarget(string derefChainBorrow) { result = super.getTarget(derefChainBorrow) }
 
@@ -444,23 +490,47 @@ private module Input3 implements InputSig3 {
 
   bindingset[derefChainBorrow]
   Type inferCallArgumentType(Call call, string derefChainBorrow, int pos, TypePath path) {
+    exists(FunctionPosition fpos |
+      pos = fpos.asPosition() and
+      result = call.(AssocFunctionResolution::OperationAssocFunctionCall).getTypeAt(fpos, path)
+    )
+    or
+    not call instanceof Operation and
     result =
       call.(FunctionCallMatchingInput::Access).getInferredArgumentType(derefChainBorrow, pos, path)
   }
 
-  Type inferCallReturnType(Call call, TypePath path) {
+  Type inferCallType(Call call, TypePath path) {
     exists(TypePath path0 |
-      result = M3::inferCallReturnTypeDefault(call, _, path0) and
+      result = M3::inferCallTypeDefault(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
+      if call instanceof IndexExpr or call instanceof DerefExpr
+      then path0.isCons(getRefTypeParameter(_), path)
+      else path = path0
+    )
+  }
+
+  Type inferCallTypeContextual(Call call, TypePath path) {
+    exists(TypePath path0 |
+      result = inferType(call, path0) and
+      // index expression `x[i]` desugars to `*x.index(i)`, so we must account for
+      // the implicit deref
+      if call instanceof IndexExpr or call instanceof DerefExpr
+      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
-      not call.(AssocFunctionResolution::AssocFunctionCall).hasReceiverAtPos(pos)
+    exists(FunctionCallMatchingInput::Access call, FunctionPosition pos, TypePath path0 |
+      result = inferCallArgumentTypeContextual(call, pos.asPosition(), n, _, _, path0) and
+      not call.(AssocFunctionResolution::AssocFunctionCall).hasReceiverAtPos(pos) and
+      if call.(AssocFunctionResolution::OperationAssocFunctionCall).implicitBorrowAt(pos, _)
+      then
+        // adjust for implicit borrow
+        path0.isCons(getRefTypeParameter(_), path)
+      else path = path0
     )
     or
     exists(FunctionCallMatchingInput::Access a |
@@ -537,60 +607,6 @@ private module Input3 implements InputSig3 {
     )
   }
 
-  class Operator extends Callable {
-    private Method getSelfOrImpl() {
-      result = this
-      or
-      this.implements(result)
-    }
-
-    pragma[nomagic]
-    private predicate borrowsAt(int pos) {
-      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 = 0 and borrows >= 1
-          or
-          pos = 1 and
-          borrows >= 2
-        )
-      )
-    }
-
-    pragma[nomagic]
-    private predicate derefsReturn() { this.getSelfOrImpl() = any(DerefTrait t).getDerefFunction() }
-
-    Type getParameterType(int pos, TypePath path) {
-      exists(TypePath path0 | result = super.getParameterType(pos, path0) |
-        if this.borrowsAt(pos) then path0.isCons(getRefTypeParameter(_), path) else path0 = path
-      )
-    }
-
-    Type getReturnType(TypePath path) {
-      exists(TypePath path0 | result = super.getReturnType(path0) |
-        if this.derefsReturn() then path0.isCons(getRefTypeParameter(_), path) else path0 = path
-      )
-    }
-  }
-
-  class Operation extends AssocFunctionResolution::OperationAssocFunctionCall {
-    Type getTypeArgument(TypeArgumentPosition apos, TypePath path) { none() }
-
-    AstNode getOperand(int i) {
-      exists(FunctionPosition pos |
-        result = this.getNodeAt(pos) and
-        i = pos.asPosition()
-      )
-    }
-
-    Operator getTarget() {
-      exists(ImplOrTraitItemNode i |
-        result = this.resolveCallTarget(i, _, _, _) // mutual recursion
-      )
-    }
-  }
-
   final class Constructor = ConstructorImpl;
 
   abstract private class ConstructorImpl extends Addressable {
@@ -722,33 +738,10 @@ private module Input3 implements InputSig3 {
     override AstNode getArgument(int i) { none() }
   }
 
-  abstract class Parameter extends Rust::ParamBase {
-    abstract AstNode getPattern();
-
-    abstract TypeMention getType();
-  }
-
-  private class SelfParamParameter extends Parameter, SelfParam {
-    override AstNode getPattern() { result = this }
-
-    override TypeMention getType() {
-      result = super.getTypeRepr() or
-      result = this.(ShorthandSelfParameterMention)
-    }
-  }
-
-  private class ParamParameter extends Parameter, Param {
-    override AstNode getPattern() { result = this.getPat() }
-
-    override TypeMention getType() { result = this.getTypeRepr() }
-  }
-
-  class Closure extends Rust::ClosureExpr {
-    Parameter getParameter(int i) { result = super.getParam(i) }
-
-    AstNode getBody() { result = super.getBody() }
-
-    TypeMention getReturnType() { result = this.getRetType().getTypeRepr() }
+  class Closure extends Expr, Callable instanceof Rust::ClosureExpr {
+    // Parameter getParameter(int i) { result = super.getParam(i) }
+    // AstNode getBody() { result = super.getBody() }
+    // TypeMention getReturnType() { result = this.getRetType().getTypeRepr() }
   }
 
   class ClosureParameterPseudoType = T::ClosureParameterPseudoType;
@@ -975,8 +968,6 @@ private module Input3 implements InputSig3 {
     result = inferDeconstructionPatType(n, path)
     or
     result = inferUnknownType(n, path)
-    // or
-    // result = inferParamPatType(n, path)
   }
 }
 
@@ -1060,26 +1051,24 @@ private class FunctionDeclaration extends Function {
       i.asSome().getAnAssocItem() = this
     )
   }
-
-  pragma[nomagic]
-  Type getParameterType(int j, TypePath path) {
-    exists(FunctionPosition fpos | j = fpos.asPosition() |
-      result = fpos.getTypeMention(this).getTypeAt(path)
-    )
-  }
-
-  Type getReturnType(TypePath path) {
-    if this.isAsync()
-    then
-      path.isEmpty() and
-      result = getFutureTraitType()
-      or
-      exists(TypePath suffix |
-        result = getReturnTypeMention(this).getTypeAt(suffix) and
-        path = TypePath::cons(getDynFutureOutputTypeParameter(), suffix)
-      )
-    else result = getReturnTypeMention(this).getTypeAt(path)
-  }
+  // pragma[nomagic]
+  // Type getParameterType(int j, TypePath path) {
+  //   exists(FunctionPosition fpos | j = fpos.asPosition() |
+  //     result = fpos.getTypeMention(this).getTypeAt(path)
+  //   )
+  // }
+  // Type getReturnType(TypePath path) {
+  //   if this.isAsync()
+  //   then
+  //     path.isEmpty() and
+  //     result = getFutureTraitType()
+  //     or
+  //     exists(TypePath suffix |
+  //       result = getReturnTypeMention(this).getTypeAt(suffix) and
+  //       path = TypePath::cons(getDynFutureOutputTypeParameter(), suffix)
+  //     )
+  //   else result = getReturnTypeMention(this).getTypeAt(path)
+  // }
 }
 
 private class AssocFunctionDeclaration extends FunctionDeclaration {
@@ -1284,10 +1273,8 @@ private module ContextualTyping {
    * possibly via a constraint on another mentioned type parameter.
    */
   pragma[nomagic]
-  private predicate assocFunctionMentionsTypeParameterAtNonRetPos(
-    FunctionDeclaration f, TypeParameter tp
-  ) {
-    tp = f.getParameterType(_, _)
+  private predicate assocFunctionMentionsTypeParameterAtNonRetPos(Function f, TypeParameter tp) {
+    tp = f.(Input3::Callable).getParameter(_).getType().getTypeAt(_)
     or
     exists(TypeParameter mid |
       assocFunctionMentionsTypeParameterAtNonRetPos(f, mid) and
@@ -1309,7 +1296,7 @@ private module ContextualTyping {
   private predicate assocFunctionReturnContextTypedAt(
     FunctionDeclaration f, TypePath path, TypeParameter tp
   ) {
-    tp = f.getReturnType(path) and
+    tp = Input3::getCallableReturnType(f, path) and
     not assocFunctionMentionsTypeParameterAtNonRetPos(f, tp)
   }
 
@@ -2175,7 +2162,7 @@ private module AssocFunctionResolution {
       result = this.getOperand(pos.asPosition())
     }
 
-    private predicate implicitBorrowAt(FunctionPosition pos, boolean isMutable) {
+    predicate implicitBorrowAt(FunctionPosition pos, boolean isMutable) {
       exists(int borrows | this.isOverloaded(_, _, borrows) |
         pos.asPosition() = 0 and
         borrows >= 1 and
@@ -2871,11 +2858,6 @@ private module FunctionCallMatchingInput {
 
   private class AssocFunctionCallAccess extends AccessImpl instanceof AssocFunctionResolution::AssocFunctionCall
   {
-    AssocFunctionCallAccess() {
-      // handled in the `OperationMatchingInput` module
-      not this instanceof Operation
-    }
-
     pragma[nomagic]
     override Type getTypeArgument(TypeArgumentPosition apos, TypePath path) {
       result =
@@ -2985,8 +2967,8 @@ private module FunctionCallMatchingInput {
       derefChainBorrow = noDerefChainBorrow() and
       exists(FunctionDeclaration f, TypeParameter tp |
         f = super.resolveCallTargetViaPathResolution() and
-        tp = f.getReturnType(path) and
-        not tp = f.getParameterType(_, _) and
+        tp = Input3::getCallableReturnType(f, path) and
+        not tp = f.(Input3::Callable).getParameter(_).getType().getTypeAt(_) and
         // check that no explicit type arguments have been supplied for `tp`
         not exists(TypeArgumentPosition tapos |
           this.hasTypeArgument(tapos) and