wip

Author: hvitved

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

@@ -1316,6 +1316,13 @@ private module MethodCallResolution {
       mc.isMethodCall(name, arity)
     }
 
+    pragma[nomagic]
+    private predicate isNotInherentTarget(Impl impl) {
+      IsInstantiationOf<MethodCallCand, FunctionPositionType, MethodCallIsInstantiationOfInput>::isNotInstantiationOf(this,
+        impl, _) and
+      not impl.hasTrait()
+    }
+
     /**
      * Holds if this method call has no inherent target, i.e., it does not
      * resolve to a method in an `impl` block for the type of the receiver.
@@ -1328,8 +1335,7 @@ private module MethodCallResolution {
           methodCandidate(rootType, name, arity, impl, _) and
           not impl.hasTrait()
         |
-          IsInstantiationOf<MethodCallCand, FunctionPositionType, MethodCallIsInstantiationOfInput>::isNotInstantiationOf(this,
-            impl, _)
+          this.isNotInherentTarget(impl)
         )
       )
     }
@@ -2000,10 +2006,11 @@ private module OperationResolution {
     }
 
     pragma[nomagic]
-    predicate isOperation(Type rootType, string name, int arity) {
+    predicate isOperation(Type rootType, Trait trait, string name, int arity) {
       name = this.(Call).getMethodName() and
       arity = this.(Call).getNumberOfArguments() and
-      rootType = this.getTypeAt(TypePath::nil())
+      rootType = this.getTypeAt(TypePath::nil()) and
+      trait = this.(Call).getTrait()
     }
 
     pragma[nomagic]
@@ -2055,9 +2062,13 @@ private module OperationResolution {
 
     pragma[nomagic]
     predicate potentialInstantiationOf(Op op, TypeAbstraction abs, FunctionPositionType constraint) {
-      exists(Type rootType, string name, int arity |
-        op.isOperation(rootType, name, arity) and
-        methodCandidateTrait(rootType, op.(Call).getTrait(), name, arity, abs, constraint)
+      exists(Type rootType, Trait trait, string name, int arity |
+        op.isOperation(rootType, trait, name, arity) and
+        MethodCallResolution::methodCandidate(rootType, name, arity, abs, constraint)
+      |
+        trait = abs.(ImplItemNode).resolveTraitTy()
+        or
+        trait = abs
       )
     }
 
@@ -2330,7 +2341,17 @@ private module FieldExprMatchingInput implements MatchingInputSig {
     }
 
     Type getInferredType(AccessPosition apos, TypePath path) {
-      result = inferType(this.getNodeAt(apos), path)
+      exists(TypePath path0 | result = inferType(this.getNodeAt(apos), path0) |
+        if apos.isSelf()
+        then
+          // adjust for implicit deref
+          path0.isCons(TRefTypeParameter(), path)
+          or
+          not path0.isCons(TRefTypeParameter(), _) and
+          not (result = TRefType() and path0.isEmpty()) and
+          path = path0
+        else path = path0
+      )
     }
 
     Declaration getTarget() {
@@ -2347,28 +2368,6 @@ private module FieldExprMatchingInput implements MatchingInputSig {
   predicate accessDeclarationPositionMatch(AccessPosition apos, DeclarationPosition dpos) {
     apos = dpos
   }
-
-  bindingset[apos, target, path, t]
-  pragma[inline_late]
-  predicate adjustAccessType(
-    AccessPosition apos, Declaration target, TypePath path, Type t, TypePath pathAdj, Type tAdj
-  ) {
-    exists(target) and
-    if apos.isSelf()
-    then
-      // adjust for implicit deref
-      path.isCons(TRefTypeParameter(), pathAdj) and
-      tAdj = t
-      or
-      not path.isCons(TRefTypeParameter(), _) and
-      not (t = TRefType() and path.isEmpty()) and
-      pathAdj = path and
-      tAdj = t
-    else (
-      pathAdj = path and
-      tAdj = t
-    )
-  }
 }
 
 private module FieldExprMatching = Matching<FieldExprMatchingInput>;

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

@@ -1103,29 +1103,6 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
       bindingset[apos]
       bindingset[dpos]
       predicate accessDeclarationPositionMatch(AccessPosition apos, DeclarationPosition dpos);
-
-      /**
-       * Holds if matching an inferred type `t` at `path` inside an access at `apos`
-       * against the declaration `target` means that the type should be adjusted to
-       * `tAdj` at `pathAdj`.
-       *
-       * For example, in
-       *
-       * ```csharp
-       * void M(int? i) {}
-       * M(42);
-       * ```
-       *
-       * the inferred type of `42` is `int`, but it should be adjusted to `int?`
-       * when matching against `M`.
-       */
-      bindingset[apos, target, path, t]
-      default predicate adjustAccessType(
-        AccessPosition apos, Declaration target, TypePath path, Type t, TypePath pathAdj, Type tAdj
-      ) {
-        pathAdj = path and
-        tAdj = t
-      }
     }
 
     /**
@@ -1142,14 +1119,11 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
        * in `a` is `t` after adjustment by `target`.
        */
       pragma[nomagic]
-      private predicate adjustedAccessType(
+      private predicate accessType(
         Access a, State state, AccessPosition apos, Declaration target, TypePath path, Type t
       ) {
         target = a.getTarget(state) and
-        exists(TypePath path0, Type t0 |
-          t0 = a.getInferredType(state, apos, path0) and
-          adjustAccessType(apos, target, path0, t0, path, t)
-        )
+        t = a.getInferredType(state, apos, path)
       }
 
       /**
@@ -1182,7 +1156,7 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
         exists(AccessPosition apos, DeclarationPosition dpos, TypePath pathToTypeParam |
           tp = target.getDeclaredType(dpos, pathToTypeParam) and
           accessDeclarationPositionMatch(apos, dpos) and
-          adjustedAccessType(a, state, apos, target, pathToTypeParam.appendInverse(path), t)
+          accessType(a, state, apos, target, pathToTypeParam.appendInverse(path), t)
         )
       }
 
@@ -1193,7 +1167,7 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
          */
         private predicate relevantAccess(Access a, State state, AccessPosition apos, Type base) {
           exists(Declaration target, DeclarationPosition dpos |
-            adjustedAccessType(a, state, apos, target, _, _) and
+            accessType(a, state, apos, target, _, _) and
             accessDeclarationPositionMatch(apos, dpos) and
             declarationBaseType(target, dpos, base, _, _)
           )
@@ -1268,10 +1242,8 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
         }
 
         private newtype TRelevantAccess =
-          MkRelevantAccess(
-            Access a, State state, Declaration target, AccessPosition apos, TypePath path
-          ) {
-            relevantAccessConstraint(a, state, target, apos, path, _)
+          MkRelevantAccess(Access a, State state, AccessPosition apos, TypePath path) {
+            relevantAccessConstraint(a, state, _, apos, path, _)
           }
 
         /**
@@ -1281,18 +1253,19 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
         private class RelevantAccess extends MkRelevantAccess {
           Access a;
           State state;
-          Declaration target;
           AccessPosition apos;
           TypePath path;
 
-          RelevantAccess() { this = MkRelevantAccess(a, state, target, apos, path) }
+          RelevantAccess() { this = MkRelevantAccess(a, state, apos, path) }
 
           Type getTypeAt(TypePath suffix) {
-            adjustedAccessType(a, state, apos, target, path.appendInverse(suffix), result)
+            accessType(a, state, apos, _, path.appendInverse(suffix), result)
           }
 
           /** Holds if this relevant access should satisfy `constraint`. */
-          Type getConstraint() { relevantAccessConstraint(a, state, target, apos, path, result) }
+          Type getConstraint(Declaration target) {
+            relevantAccessConstraint(a, state, target, apos, path, result)
+          }
 
           string toString() {
             result = a.toString() + ", " + apos.toString() + ", " + path.toString()
@@ -1305,16 +1278,20 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
           SatisfiesConstraintInputSig<RelevantAccess>
         {
           predicate relevantConstraint(RelevantAccess at, Type constraint) {
-            constraint = at.getConstraint()
+            constraint = at.getConstraint(_)
           }
         }
 
         predicate satisfiesConstraintType(
           Access a, State state, Declaration target, AccessPosition apos, TypePath prefix,
           Type constraint, TypePath path, Type t
         ) {
-          SatisfiesConstraint<RelevantAccess, SatisfiesConstraintInput>::satisfiesConstraintType(MkRelevantAccess(a,
-              state, target, apos, prefix), constraint, path, t)
+          exists(RelevantAccess ra |
+            ra = MkRelevantAccess(a, state, apos, prefix) and
+            SatisfiesConstraint<RelevantAccess, SatisfiesConstraintInput>::satisfiesConstraintType(ra,
+              constraint, path, t) and
+            constraint = ra.getConstraint(target)
+          )
         }
       }
 
@@ -1605,29 +1582,6 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
       bindingset[apos]
       bindingset[dpos]
       predicate accessDeclarationPositionMatch(AccessPosition apos, DeclarationPosition dpos);
-
-      /**
-       * Holds if matching an inferred type `t` at `path` inside an access at `apos`
-       * against the declaration `target` means that the type should be adjusted to
-       * `tAdj` at `pathAdj`.
-       *
-       * For example, in
-       *
-       * ```csharp
-       * void M(int? i) {}
-       * M(42);
-       * ```
-       *
-       * the inferred type of `42` is `int`, but it should be adjusted to `int?`
-       * when matching against `M`.
-       */
-      bindingset[apos, target, path, t]
-      default predicate adjustAccessType(
-        AccessPosition apos, Declaration target, TypePath path, Type t, TypePath pathAdj, Type tAdj
-      ) {
-        pathAdj = path and
-        tAdj = t
-      }
     }
 
     /**
@@ -1641,8 +1595,6 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
         private import codeql.util.Unit
         import Input
 
-        predicate adjustAccessType = Input::adjustAccessType/6;
-
         class State = Unit;
 
         final private class AccessFinal = Input::Access;