WIP

Author: paldepind

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

@@ -205,6 +205,13 @@ private module Input2 implements InputSig2 {
       constraint = object.getTrait()
     )
   }
+
+  private predicate testConditionSatisfiesConstraint(
+    TypeAbstraction abs, TypeMention condition, TypeMention constraint
+  ) {
+    conditionSatisfiesConstraint(abs, condition, constraint) and
+    constraint.resolveType().(TraitType).getTrait().getName().getText() = "TryFuture"
+  }
 }
 
 private module M2 = Make2<Input2>;
@@ -1725,6 +1732,31 @@ private module BlanketImplementation {
     not exists(impl.getAttributeMacroExpansion())
   }
 
+  predicate isBlanketImplementation(Impl impl) { exists(getBlanketImplementationTypeParam(impl)) }
+
+  predicate duplicatedImpl(Impl impl1, Impl impl2) {
+    isBlanketImplementation(impl1) and
+    isBlanketImplementation(impl2) and
+    impl1 != impl2 and
+    getBlanketImplementationTypeParam(impl1).toString() =
+      getBlanketImplementationTypeParam(impl2).toString() and
+    impl1.getTrait().toString() = impl2.getTrait().toString() and
+    impl1.getLocation().getFile() != impl2.getLocation().getFile() and
+    impl1.getLocation().getFile().getBaseName() = impl2.getLocation().getFile().getBaseName()
+  }
+
+  Impl getCanonicalImpl(Impl impl) {
+    isBlanketImplementation(impl) and
+    result =
+      max(Impl impl0 |
+        duplicatedImpl(impl, impl0) or impl = impl0
+      |
+        impl0 order by impl0.getLocation().getFile().getAbsolutePath()
+      )
+  }
+
+  predicate isCanonicalBlanketImplementation(Impl impl) { impl = getCanonicalImpl(impl) }
+
   /**
    * Holds if `impl` is a blanket implementation for a type parameter and the type
    * parameter must implement `trait`.
@@ -1760,6 +1792,7 @@ private module BlanketImplementation {
   private predicate blanketImplementationMethod(
     Impl impl, Trait trait, string name, int arity, Function f
   ) {
+    isCanonicalBlanketImplementation(impl) and
     f = impl.(ImplItemNode).getASuccessor(name) and
     blanketImplementationTraitBound(impl, trait) and
     f.getParamList().hasSelfParam() and
@@ -1780,11 +1813,15 @@ private module BlanketImplementation {
     predicate relevantConstraint(MethodCall mc, Type constraint) {
       methodCallMatchesBlanketImpl(mc, _, _, constraint.(TraitType).getTrait(), _)
     }
+
+    predicate useUniversalConditions() { none() }
   }
 
   predicate debugSatisfiesConstraintType(MethodCall mc, Trait trait, TypePath path, Type ty) {
     SatisfiesConstraint<MethodCall, SatisfiesConstraintInput>::satisfiesConstraintType(mc,
-      TTrait(trait), path, ty)
+      TTrait(trait), path, ty) and
+    // 521 results
+    trait.getName().getText() = "TryFuture"
   }
 
   predicate getBlanketImpl(MethodCall mc, Type t, Impl impl, Trait trait, Function f) {
@@ -1834,8 +1871,8 @@ private Function resolveMethodCallTarget(MethodCall mc) {
   // The method comes from an `impl` block targeting the type of the receiver.
   result = getMethodFromImpl(mc)
   or
-  result = BlanketImplementation::getMethodFromBlanketImpl(mc)
-  or
+  // result = BlanketImplementation::getMethodFromBlanketImpl(mc)
+  // or
   // The type of the receiver is a type parameter and the method comes from a
   // trait bound on the type parameter.
   result = getTypeParameterMethod(mc.getTypeAt(TypePath::nil()), mc.getMethodName())

rust/ql/test/library-tests/type-inference/blanket_impl.rs

@@ -401,6 +401,59 @@ mod higher_ranked_blanket_impl {
     }
 }
 
+mod TST {
+    // 1. Elements a trait that is implemented for a type parameter
+    // 2. An extension trait
+    // 3. A blanket implementation of the extension trait for a type parameter
+
+    trait Flag {
+        fn read_flag(&self) -> bool;
+    }
+
+    trait TryFlag {
+        fn try_read_flag(&self) -> Option<bool>;
+    }
+
+    impl<Fl> TryFlag for Fl
+    where
+        Fl: Flag,
+    {
+        fn try_read_flag(&self) -> Option<bool> {
+            Some(self.read_flag())
+        }
+    }
+
+    trait TryFlagExt: TryFlag {
+        // TryFlagExt::try_read_flag_twice
+        fn try_read_flag_twice(&self) -> Option<bool> {
+            self.try_read_flag()
+        }
+    }
+
+    impl<T: TryFlag> TryFlagExt for T {}
+
+    trait AnotherTryFlag {
+        // AnotherTryFlag::try_read_flag_twice
+        fn try_read_flag_twice(&self) -> Option<bool>;
+    }
+
+    struct MyFlag {
+        flag: bool,
+    }
+
+    impl AnotherTryFlag for MyFlag {
+        // MyFlag::try_read_flag_twice
+        fn try_read_flag_twice(&self) -> Option<bool> {
+            Some(self.flag)
+        }
+    }
+
+    fn test() {
+        let my_flag = MyFlag { flag: true };
+        let result = my_flag.try_read_flag_twice(); // $ target=MyFlag::try_read_flag_twice
+    }
+}
+
 pub fn test() {
     basic_blanket_impl::test_basic_blanket(); // $ target=test_basic_blanket
     nested_blanket_impl::test_nested_blanket(); // $ target=test_nested_blanket