Rust: Improve handling of where clauses in type inference and path resolution

rust/ql/lib/codeql/rust/elements/internal/TraitImpl.qll

@@ -36,5 +36,36 @@ module Impl {
       not this.hasGenericParamList() and
       result = 0
     }
+
+    private int nrOfDirectTypeBounds() {
+      result = this.getTypeBoundList().getNumberOfBounds()
+      or
+      not this.hasTypeBoundList() and
+      result = 0
+    }
+
+    /**
+     * Gets the `index`th type bound of this trait, if any.
+     *
+     * This includes type bounds directly on the trait and bounds from any
+     * `where` clauses for `Self`.
+     */
+    TypeBound getTypeBound(int index) {
+      result = this.getTypeBoundList().getBound(index)
+      or
+      exists(WherePred wp |
+        wp = this.getWhereClause().getAPredicate() and
+        wp.getTypeRepr().(PathTypeRepr).getPath().getText() = "Self" and
+        result = wp.getTypeBoundList().getBound(index - this.nrOfDirectTypeBounds())
+      )
+    }
+
+    /**
+     * Gets a type bound of this trait.
+     *
+     * This includes type bounds directly on the trait and bounds from any
+     * `where` clauses for `Self`.
+     */
+    TypeBound getATypeBound() { result = this.getTypeBound(_) }
   }
 }

rust/ql/lib/codeql/rust/elements/internal/TypeParamImpl.qll

@@ -12,6 +12,7 @@ private import codeql.rust.elements.internal.generated.TypeParam
  */
 module Impl {
   private import rust
+  private import codeql.rust.internal.PathResolution
 
   // the following QLdoc is generated: if you need to edit it, do it in the schema file
   /**
@@ -27,6 +28,41 @@ module Impl {
     /** Gets the position of this type parameter. */
     int getPosition() { this = any(GenericParamList l).getTypeParam(result) }
 
+    private TypeBound getTypeBoundAt(int i, int j) {
+      exists(TypeBoundList tbl | result = tbl.getBound(j) |
+        tbl = this.getTypeBoundList() and i = 0
+        or
+        exists(WherePred wp |
+          wp = this.(TypeParamItemNode).getAWherePred() and
+          tbl = wp.getTypeBoundList() and
+          wp = any(WhereClause wc).getPredicate(i)
+        )
+      )
+    }
+
+    /**
+     * Gets the `index`th type bound of this type parameter, if any.
+     *
+     * This includes type bounds directly on this type parameter and bounds from
+     * any `where` clauses for this type parameter.
+     */
+    TypeBound getTypeBound(int index) {
+      result = rank[index + 1](int i, int j | | this.getTypeBoundAt(i, j) order by i, j)
+    }
+
+    /**
+     * Gets a type bound of this type parameter.
+     *
+     * This includes type bounds directly on this type parameter and bounds from
+     * any `where` clauses for this type parameter.
+     */
+    TypeBound getATypeBound() {
+      // NOTE: This predicate is used in path resolution, so it can not be
+      // defined using `getTypeBound` as that would cause non-monotonic
+      // recursion due to the `rank`.
+      result = this.getTypeBoundAt(_, _)
+    }
+
     override string toAbbreviatedString() { result = this.getName().getText() }
 
     override string toStringImpl() { result = this.getName().getText() }

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

@@ -791,9 +791,7 @@ private class StructItemNode extends TypeItemNode instanceof Struct {
 
 class TraitItemNode extends ImplOrTraitItemNode, TypeItemNode instanceof Trait {
   pragma[nomagic]
-  Path getABoundPath() {
-    result = super.getTypeBoundList().getABound().getTypeRepr().(PathTypeRepr).getPath()
-  }
+  Path getABoundPath() { result = super.getATypeBound().getTypeRepr().(PathTypeRepr).getPath() }
 
   pragma[nomagic]
   ItemNode resolveABound() { result = resolvePath(this.getABoundPath()) }
@@ -924,7 +922,8 @@ private class BlockExprItemNode extends ItemNode instanceof BlockExpr {
 }
 
 class TypeParamItemNode extends TypeItemNode instanceof TypeParam {
-  private WherePred getAWherePred() {
+  /** Gets a where predicate for this type parameter, if any */
+  WherePred getAWherePred() {
     exists(ItemNode declaringItem |
       this = resolveTypeParamPathTypeRepr(result.getTypeRepr()) and
       result = declaringItem.getADescendant() and
@@ -933,13 +932,7 @@ class TypeParamItemNode extends TypeItemNode instanceof TypeParam {
   }
 
   pragma[nomagic]
-  Path getABoundPath() {
-    exists(TypeBoundList tbl | result = tbl.getABound().getTypeRepr().(PathTypeRepr).getPath() |
-      tbl = super.getTypeBoundList()
-      or
-      tbl = this.getAWherePred().getTypeBoundList()
-    )
-  }
+  Path getABoundPath() { result = super.getATypeBound().getTypeRepr().(PathTypeRepr).getPath() }
 
   pragma[nomagic]
   ItemNode resolveABound() { result = resolvePath(this.getABoundPath()) }
@@ -956,12 +949,7 @@ class TypeParamItemNode extends TypeItemNode instanceof TypeParam {
    * ```
    */
   cached
-  predicate hasTraitBound() {
-    Stages::PathResolutionStage::ref() and
-    exists(this.getABoundPath())
-    or
-    exists(this.getAWherePred())
-  }
+  predicate hasTraitBound() { Stages::PathResolutionStage::ref() and exists(this.getABoundPath()) }
 
   /**
    * Holds if this type parameter has no trait bound. Examples:

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

@@ -151,7 +151,7 @@ private module Input2 implements InputSig2 {
   TypeMention getABaseTypeMention(Type t) { none() }
 
   TypeMention getATypeParameterConstraint(TypeParameter tp) {
-    result = tp.(TypeParamTypeParameter).getTypeParam().getTypeBoundList().getABound().getTypeRepr()
+    result = tp.(TypeParamTypeParameter).getTypeParam().getATypeBound().getTypeRepr()
     or
     result = tp.(SelfTypeParameter).getTrait()
     or
@@ -184,12 +184,12 @@ private module Input2 implements InputSig2 {
     exists(Trait trait |
       abs = trait and
       condition = trait and
-      constraint = trait.getTypeBoundList().getABound().getTypeRepr()
+      constraint = trait.getATypeBound().getTypeRepr()
     )
     or
     // trait bounds on type parameters
     exists(TypeParam param |
-      abs = param.getTypeBoundList().getABound() and
+      abs = param.getATypeBound() and
       condition = param and
       constraint = abs.(TypeBound).getTypeRepr()
     )

rust/ql/test/library-tests/path-resolution/CONSISTENCY/PathResolutionConsistency.expected

@@ -2,6 +2,6 @@ multipleCallTargets
 | main.rs:118:9:118:11 | f(...) |
 | proc_macro.rs:9:5:11:5 | ...::new(...) |
 multiplePathResolutions
-| main.rs:626:3:626:12 | proc_macro |
-| main.rs:632:7:632:16 | proc_macro |
-| main.rs:635:7:635:16 | proc_macro |
+| main.rs:641:3:641:12 | proc_macro |
+| main.rs:647:7:647:16 | proc_macro |
+| main.rs:650:7:650:16 | proc_macro |

rust/ql/test/library-tests/path-resolution/main.rs

@@ -312,6 +312,21 @@ mod m15 {
         }
     } // I82
 
+    #[rustfmt::skip]
+    trait Trait3<
+        TT // ITT
+    >
+    where
+        Self: Trait1, // $ item=ITrait3 item=I79
+        TT: Trait1, // $ item=ITT item=I79
+    {
+        fn f(&self, tt: TT) { // $ item=ITT
+            Self::g(self); // $ item=I80
+            TT::g(&tt); // $ item=I80
+            self.g(); // $ item=I80
+        }
+    } // ITrait3
+
     struct S; // I81
 
     #[rustfmt::skip]