wip7

Author: hvitved

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

@@ -286,6 +286,8 @@ private module Input3 implements InputSig3 {
     (exists(resolveTupleFieldExpr(_, _)) implies any())
   }
 
+  predicate inferType = M3::inferType/2;
+
   class BoolType extends DataType {
     BoolType() { this.getTypeItem() instanceof Builtins::Bool }
   }
@@ -366,41 +368,54 @@ private module Input3 implements InputSig3 {
     override AstNode getRightOperand() { result = this.getInitializer() }
   }
 
-  class CallTarget extends FunctionCallMatchingInput::Declaration {
+  class CallResolutionContext = FunctionCallMatchingInput::AccessEnvironment;
+
+  class TypePosition = FunctionPosition;
+
+  class Callable extends FunctionCallMatchingInput::Declaration {
     TypeMention getAdditionalTypeParameterConstraint(TypeParameter tp) {
       result =
         tp.(TypeParamTypeParameter)
             .getTypeParam()
             .getAdditionalTypeBound(this.getFunction(), _)
             .getTypeRepr()
     }
-
-    Type getReturnType(TypePath path) {
-      exists(FunctionPosition pos |
-        pos.isReturn() and
-        result = super.getDeclaredType(pos, path)
-      )
-    }
-
-    Type getParameterType(int index, TypePath path) {
-      none() // todo
-    }
   }
 
   class Call extends Expr instanceof FunctionCallMatchingInput::Access {
     Type getTypeArgument(TypeArgumentPosition apos, TypePath path) {
       result = super.getTypeArgument(apos, path)
     }
 
+    AstNode getNodeAt(TypePosition pos) { result = super.getNodeAt(pos) }
+
     /** Gets the target of this call. */
-    CallTarget getTargetCertain() {
+    Callable getTargetCertain() {
       exists(ImplOrTraitItemNodeOption i, FunctionDeclaration f, Path p |
         result.isFunction(i, f) and
         p = CallExprImpl::getFunctionPath(this) and
         f = resolvePath(p) and
         f.isDirectlyFor(i)
       )
     }
+
+    Callable getTarget(string derefChainBorrow) { result = super.getTarget(derefChainBorrow) }
+  }
+
+  bindingset[derefChainBorrow]
+  Type inferCallTypeIn(Call call, string derefChainBorrow, FunctionPosition pos, TypePath path) {
+    result = call.(FunctionCallMatchingInput::Access).getInferredType(derefChainBorrow, pos, path)
+  }
+
+  Type inferCallTypeOut(AstNode n, TypePosition pos, TypePath path) {
+    result = inferFunctionCallTypeNonSelf(n, pos, path)
+    or
+    exists(FunctionCallMatchingInput::Access a |
+      result = inferFunctionCallTypeSelf(a, n, DerefChain::nil(), path) and
+      if a.(AssocFunctionResolution::AssocFunctionCall).hasReceiver()
+      then not path.isEmpty()
+      else any()
+    )
   }
 
   predicate certainTypeEqualityInput(AstNode n1, TypePath prefix1, AstNode n2, TypePath prefix2) {
@@ -553,8 +568,6 @@ private module Input3 implements InputSig3 {
   Type inferTypeInput(AstNode n, TypePath path) {
     result = inferAssignmentOperationType(n, path)
     or
-    result = inferFunctionCallType(n, path)
-    or
     result = inferConstructionType(n, path)
     or
     result = inferOperationType(n, path)
@@ -1094,53 +1107,6 @@ private module ContextTyping {
       )
     }
   }
-
-  pragma[nomagic]
-  private predicate hasUnknownTypeAt(AstNode n, TypePath path) {
-    inferType(n, path) = TUnknownType()
-  }
-
-  pragma[nomagic]
-  private predicate hasUnknownType(AstNode n) { hasUnknownTypeAt(n, _) }
-
-  newtype FunctionPositionKind =
-    SelfKind() or
-    ReturnKind() or
-    PositionalKind()
-
-  signature Type inferCallTypeSig(AstNode n, FunctionPositionKind kind, TypePath path);
-
-  /**
-   * Given a predicate `inferCallType` for inferring the type of a call at a given
-   * position, this module exposes the predicate `check`, which wraps the input
-   * predicate and checks that types are only propagated into arguments when they
-   * are context-typed.
-   */
-  module CheckContextTyping<inferCallTypeSig/3 inferCallType> {
-    pragma[nomagic]
-    private Type inferCallNonReturnType(
-      AstNode n, FunctionPositionKind kind, TypePath prefix, TypePath path
-    ) {
-      result = inferCallType(n, kind, path) and
-      hasUnknownType(n) and
-      kind != ReturnKind() and
-      prefix = path.getAPrefix()
-    }
-
-    pragma[nomagic]
-    Type check(AstNode n, TypePath path) {
-      result = inferCallType(n, ReturnKind(), path)
-      or
-      exists(FunctionPositionKind kind, TypePath prefix |
-        result = inferCallNonReturnType(n, kind, prefix, path) and
-        hasUnknownTypeAt(n, prefix)
-      |
-        // Never propagate type information directly into the receiver, since its type
-        // must already have been known in order to resolve the call
-        if kind = SelfKind() then not prefix.isEmpty() else any()
-      )
-    }
-  }
 }
 
 /**
@@ -2836,22 +2802,20 @@ private module FunctionCallMatchingInput implements MatchingWithEnvironmentInput
   }
 }
 
-private module FunctionCallMatching = MatchingWithEnvironment<FunctionCallMatchingInput>;
-
 pragma[nomagic]
 private Type inferFunctionCallType0(
   FunctionCallMatchingInput::Access call, FunctionPosition pos, AstNode n, DerefChain derefChain,
   BorrowKind borrow, TypePath path
 ) {
   exists(TypePath path0 |
-    n = call.getNodeAt(pos) and
     exists(string derefChainBorrow |
       FunctionCallMatchingInput::decodeDerefChainBorrow(derefChainBorrow, derefChain, borrow)
     |
-      result = FunctionCallMatching::inferAccessType(call, derefChainBorrow, pos, path0)
-      or
+      n = call.getNodeAt(pos) and
       call.hasUnknownTypeAt(derefChainBorrow, pos, path0) and
       result = TUnknownType()
+      or
+      result = inferCallTypeOut(call, pos, n, derefChainBorrow, path0)
     )
   |
     if
@@ -2919,31 +2883,6 @@ private Type inferFunctionCallTypeSelf(
   )
 }
 
-private Type inferFunctionCallTypePreCheck(
-  AstNode n, ContextTyping::FunctionPositionKind kind, TypePath path
-) {
-  exists(FunctionPosition pos |
-    result = inferFunctionCallTypeNonSelf(n, pos, path) and
-    if pos.isPosition()
-    then kind = ContextTyping::PositionalKind()
-    else kind = ContextTyping::ReturnKind()
-  )
-  or
-  exists(FunctionCallMatchingInput::Access a |
-    result = inferFunctionCallTypeSelf(a, n, DerefChain::nil(), path) and
-    if a.(AssocFunctionResolution::AssocFunctionCall).hasReceiver()
-    then kind = ContextTyping::SelfKind()
-    else kind = ContextTyping::PositionalKind()
-  )
-}
-
-/**
- * Gets the type of `n` at `path`, where `n` is either a function call or an
- * argument/receiver of a function call.
- */
-private predicate inferFunctionCallType =
-  ContextTyping::CheckContextTyping<inferFunctionCallTypePreCheck/3>::check/2;
-
 abstract private class Constructor extends Addressable {
   final TypeParameter getTypeParameter(TypeParameterPosition ppos) {
     typeParamMatchPosition(this.getTypeItem().getGenericParamList().getATypeParam(), result, ppos)
@@ -3102,15 +3041,8 @@ private module ConstructionMatchingInput implements MatchingInputSig {
 private module ConstructionMatching = Matching<ConstructionMatchingInput>;
 
 pragma[nomagic]
-private Type inferConstructionTypePreCheck(
-  AstNode n, ContextTyping::FunctionPositionKind kind, TypePath path
-) {
-  exists(ConstructionMatchingInput::Access a, FunctionPosition pos |
-    n = a.getNodeAt(pos) and
-    if pos.isPosition()
-    then kind = ContextTyping::PositionalKind()
-    else kind = ContextTyping::ReturnKind()
-  |
+private Type inferConstructionTypePreCheck(AstNode n, FunctionPosition pos, TypePath path) {
+  exists(ConstructionMatchingInput::Access a | n = a.getNodeAt(pos) |
     result = ConstructionMatching::inferAccessType(a, pos, path)
     or
     a.hasUnknownTypeAt(pos, path) and
@@ -3119,7 +3051,7 @@ private Type inferConstructionTypePreCheck(
 }
 
 private predicate inferConstructionType =
-  ContextTyping::CheckContextTyping<inferConstructionTypePreCheck/3>::check/2;
+  CheckContextTyping<inferConstructionTypePreCheck/3>::check/2;
 
 /**
  * A matching configuration for resolving types of operations like `a + b`.
@@ -3184,23 +3116,15 @@ private module OperationMatchingInput implements MatchingInputSig {
 private module OperationMatching = Matching<OperationMatchingInput>;
 
 pragma[nomagic]
-private Type inferOperationTypePreCheck(
-  AstNode n, ContextTyping::FunctionPositionKind kind, TypePath path
-) {
-  exists(OperationMatchingInput::Access a, FunctionPosition pos |
+private Type inferOperationTypePreCheck(AstNode n, FunctionPosition pos, TypePath path) {
+  exists(OperationMatchingInput::Access a |
     n = a.getNodeAt(pos) and
     result = OperationMatching::inferAccessType(a, pos, path) and
-    if pos.asPosition() = 0
-    then kind = ContextTyping::SelfKind()
-    else
-      if pos.isPosition()
-      then kind = ContextTyping::PositionalKind()
-      else kind = ContextTyping::ReturnKind()
+    if pos.asPosition() = 0 then not path.isEmpty() else any()
   )
 }
 
-private predicate inferOperationType =
-  ContextTyping::CheckContextTyping<inferOperationTypePreCheck/3>::check/2;
+private predicate inferOperationType = CheckContextTyping<inferOperationTypePreCheck/3>::check/2;
 
 pragma[nomagic]
 private Type getFieldExprLookupType(FieldExpr fe, string name, DerefChain derefChain) {
@@ -3815,11 +3739,10 @@ private module Debug {
     t = self.getTypeAt(path)
   }
 
-  predicate debugInferFunctionCallType(AstNode n, TypePath path, Type t) {
-    n = getRelevantLocatable() and
-    t = inferFunctionCallType(n, path)
-  }
-
+  // predicate debugInferFunctionCallType(AstNode n, TypePath path, Type t) {
+  //   n = getRelevantLocatable() and
+  //   t = inferFunctionCallType(n, path)
+  // }
   predicate debugInferConstructionType(AstNode n, TypePath path, Type t) {
     n = getRelevantLocatable() and
     t = inferConstructionType(n, path)

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

@@ -10252,6 +10252,7 @@ inferType
 | main.rs:1412:17:1412:20 | self | TRef.TSlice | main.rs:1410:14:1410:23 | T |
 | main.rs:1412:17:1412:27 | self.get(...) |  | {EXTERNAL LOCATION} | Option |
 | main.rs:1412:17:1412:27 | self.get(...) | T | {EXTERNAL LOCATION} | & |
+| main.rs:1412:17:1412:27 | self.get(...) | T.TRef | main.rs:1410:14:1410:23 | T |
 | main.rs:1412:17:1412:36 | ... .unwrap() |  | {EXTERNAL LOCATION} | & |
 | main.rs:1412:17:1412:36 | ... .unwrap() | TRef | main.rs:1410:14:1410:23 | T |
 | main.rs:1412:26:1412:26 | 0 |  | {EXTERNAL LOCATION} | i32 |
@@ -11600,6 +11601,8 @@ inferType
 | main.rs:2221:18:2221:21 | true |  | {EXTERNAL LOCATION} | bool |
 | main.rs:2223:9:2223:15 | S(...) |  | main.rs:2107:5:2107:19 | S |
 | main.rs:2223:9:2223:15 | S(...) | T | {EXTERNAL LOCATION} | i64 |
+| main.rs:2223:9:2223:15 | S(...) | T | main.rs:2107:5:2107:19 | S |
+| main.rs:2223:9:2223:15 | S(...) | T.T | {EXTERNAL LOCATION} | i64 |
 | main.rs:2223:9:2223:31 | ... .my_add(...) |  | main.rs:2107:5:2107:19 | S |
 | main.rs:2223:9:2223:31 | ... .my_add(...) | T | {EXTERNAL LOCATION} | i64 |
 | main.rs:2223:9:2223:31 | ... .my_add(...) | T | main.rs:2107:5:2107:19 | S |
@@ -11618,6 +11621,8 @@ inferType
 | main.rs:2224:24:2224:27 | 3i64 |  | {EXTERNAL LOCATION} | i64 |
 | main.rs:2225:9:2225:15 | S(...) |  | main.rs:2107:5:2107:19 | S |
 | main.rs:2225:9:2225:15 | S(...) | T | {EXTERNAL LOCATION} | i64 |
+| main.rs:2225:9:2225:15 | S(...) | T | {EXTERNAL LOCATION} | & |
+| main.rs:2225:9:2225:15 | S(...) | T.TRef | {EXTERNAL LOCATION} | i64 |
 | main.rs:2225:9:2225:29 | ... .my_add(...) |  | main.rs:2107:5:2107:19 | S |
 | main.rs:2225:9:2225:29 | ... .my_add(...) | T | {EXTERNAL LOCATION} | i64 |
 | main.rs:2225:11:2225:14 | 1i64 |  | {EXTERNAL LOCATION} | i64 |