Rust: Handle more explicit type arguments in type inference

hvitved · hvitved · commit 165aae3bd86e · 2025-06-24T16:12:15.000+02:00
diff --git a/rust/ql/lib/codeql/rust/elements/internal/CallImpl.qll b/rust/ql/lib/codeql/rust/elements/internal/CallImpl.qll
@@ -67,7 +67,7 @@ module Impl {
     }
   }
 
-  /** Holds if the call expression dispatches to a trait method. */
+  /** Holds if the call expression dispatches to a method. */
   private predicate callIsMethodCall(CallExpr call, Path qualifier, string methodName) {
     exists(Path path, Function f |
       path = call.getFunction().(PathExpr).getPath() and
diff --git a/rust/ql/lib/codeql/rust/internal/PathResolution.qll b/rust/ql/lib/codeql/rust/internal/PathResolution.qll
@@ -181,6 +181,9 @@ abstract class ItemNode extends Locatable {
     result = this.(TypeParamItemNode).resolveABound().getASuccessorRec(name).(AssocItemNode)
     or
     result = this.(ImplTraitTypeReprItemNode).resolveABound().getASuccessorRec(name).(AssocItemNode)
+    or
+    result = this.(TypeAliasItemNode).resolveAlias().getASuccessorRec(name) and
+    not result instanceof TypeParam
   }
 
   /**
@@ -289,6 +292,8 @@ abstract class ItemNode extends Locatable {
   Location getLocation() { result = super.getLocation() }
 }
 
+abstract class TypeItemNode extends ItemNode { }
+
 /** A module or a source file. */
 abstract private class ModuleLikeNode extends ItemNode {
   /** Gets an item that may refer directly to items defined in this module. */
@@ -438,7 +443,7 @@ private class ConstItemNode extends AssocItemNode instanceof Const {
   override TypeParam getTypeParam(int i) { none() }
 }
 
-private class EnumItemNode extends ItemNode instanceof Enum {
+private class EnumItemNode extends TypeItemNode instanceof Enum {
   override string getName() { result = Enum.super.getName().getText() }
 
   override Namespace getNamespace() { result.isType() }
@@ -739,7 +744,7 @@ private class ModuleItemNode extends ModuleLikeNode instanceof Module {
   }
 }
 
-private class StructItemNode extends ItemNode instanceof Struct {
+private class StructItemNode extends TypeItemNode instanceof Struct {
   override string getName() { result = Struct.super.getName().getText() }
 
   override Namespace getNamespace() {
@@ -774,7 +779,7 @@ private class StructItemNode extends ItemNode instanceof Struct {
   }
 }
 
-class TraitItemNode extends ImplOrTraitItemNode instanceof Trait {
+class TraitItemNode extends ImplOrTraitItemNode, TypeItemNode instanceof Trait {
   pragma[nomagic]
   Path getABoundPath() {
     result = super.getTypeBoundList().getABound().getTypeRepr().(PathTypeRepr).getPath()
@@ -831,7 +836,10 @@ class TraitItemNode extends ImplOrTraitItemNode instanceof Trait {
   }
 }
 
-class TypeAliasItemNode extends AssocItemNode instanceof TypeAlias {
+class TypeAliasItemNode extends TypeItemNode, AssocItemNode instanceof TypeAlias {
+  pragma[nomagic]
+  ItemNode resolveAlias() { result = resolvePathFull(super.getTypeRepr().(PathTypeRepr).getPath()) }
+
   override string getName() { result = TypeAlias.super.getName().getText() }
 
   override predicate hasImplementation() { super.hasTypeRepr() }
@@ -847,7 +855,7 @@ class TypeAliasItemNode extends AssocItemNode instanceof TypeAlias {
   override string getCanonicalPath(Crate c) { none() }
 }
 
-private class UnionItemNode extends ItemNode instanceof Union {
+private class UnionItemNode extends TypeItemNode instanceof Union {
   override string getName() { result = Union.super.getName().getText() }
 
   override Namespace getNamespace() { result.isType() }
@@ -905,7 +913,7 @@ private class BlockExprItemNode extends ItemNode instanceof BlockExpr {
   override string getCanonicalPath(Crate c) { none() }
 }
 
-class TypeParamItemNode extends ItemNode instanceof TypeParam {
+class TypeParamItemNode extends TypeItemNode instanceof TypeParam {
   private WherePred getAWherePred() {
     exists(ItemNode declaringItem |
       this = resolveTypeParamPathTypeRepr(result.getTypeRepr()) and
diff --git a/rust/ql/lib/codeql/rust/internal/TypeInference.qll b/rust/ql/lib/codeql/rust/internal/TypeInference.qll
@@ -10,6 +10,7 @@ private import codeql.typeinference.internal.TypeInference
 private import codeql.rust.frameworks.stdlib.Stdlib
 private import codeql.rust.frameworks.stdlib.Builtins as Builtins
 private import codeql.rust.elements.Call
+private import codeql.rust.elements.internal.CallImpl::Impl as CallImpl
 
 class Type = T::Type;
 
@@ -597,13 +598,13 @@ private module CallExprBaseMatchingInput implements MatchingInputSig {
     override TypeParameter getTypeParameter(TypeParameterPosition ppos) {
       typeParamMatchPosition(this.getGenericParamList().getATypeParam(), result, ppos)
       or
-      exists(TraitItemNode trait | this = trait.getAnAssocItem() |
-        typeParamMatchPosition(trait.getTypeParam(_), result, ppos)
+      exists(ImplOrTraitItemNode i | this = i.getAnAssocItem() |
+        typeParamMatchPosition(i.getTypeParam(_), result, ppos)
         or
-        ppos.isImplicit() and result = TSelfTypeParameter(trait)
+        ppos.isImplicit() and result = TSelfTypeParameter(i)
         or
         ppos.isImplicit() and
-        result.(AssociatedTypeTypeParameter).getTrait() = trait
+        result.(AssociatedTypeTypeParameter).getTrait() = i
       )
       or
       ppos.isImplicit() and
@@ -625,6 +626,33 @@ private module CallExprBaseMatchingInput implements MatchingInputSig {
         or
         result = inferImplicitSelfType(self, path) // `self` parameter without type annotation
       )
+      or
+      // For associated functions, we may also need to match type arguments against
+      // the `Self` type. For example, in
+      //
+      // ```rust
+      // struct Foo<T>(T);
+      //
+      // impl<T : Default> Foo<T> {
+      //   fn default() -> Self {
+      //     Foo(Default::default())
+      //   }
+      // }
+      //
+      // Foo::<i32>::default();
+      // ```
+      //
+      // we need to match `i32` against the type parameter `T` of the `impl` block.
+      exists(ImplOrTraitItemNode i |
+        this = i.getAnAssocItem() and
+        dpos.isSelf() and
+        not this.getParamList().hasSelfParam()
+      |
+        result = TSelfTypeParameter(i) and
+        path.isEmpty()
+        or
+        result = resolveImplSelfType(i, path)
+      )
     }
 
     private Type resolveRetType(TypePath path) {
@@ -696,6 +724,14 @@ private module CallExprBaseMatchingInput implements MatchingInputSig {
 
     Type getInferredType(AccessPosition apos, TypePath path) {
       result = inferType(this.getNodeAt(apos), path)
+      or
+      // The `Self` type is supplied explicitly as a type qualifier, e.g. `Foo::<Bar>::baz()`
+      apos = TArgumentAccessPosition(CallImpl::TSelfArgumentPosition(), false, false) and
+      exists(PathExpr pe, TypeMention tm |
+        pe = this.(CallExpr).getFunction() and
+        tm = pe.getPath().getQualifier() and
+        result = tm.resolveTypeAt(path)
+      )
     }
 
     Declaration getTarget() {
@@ -1110,12 +1146,7 @@ private Type inferForLoopExprType(AstNode n, TypePath path) {
 }
 
 final class MethodCall extends Call {
-  MethodCall() {
-    exists(this.getReceiver()) and
-    // We want the method calls that don't have a path to a concrete method in
-    // an impl block. We need to exclude calls like `MyType::my_method(..)`.
-    (this instanceof CallExpr implies exists(this.getTrait()))
-  }
+  MethodCall() { exists(this.getReceiver()) }
 
   /** Gets the type of the receiver of the method call at `path`. */
   Type getTypeAt(TypePath path) {
diff --git a/rust/ql/lib/codeql/rust/internal/TypeMention.qll b/rust/ql/lib/codeql/rust/internal/TypeMention.qll
@@ -15,7 +15,7 @@ abstract class TypeMention extends AstNode {
 
   /** Gets the sub mention at `path`. */
   pragma[nomagic]
-  TypeMention getMentionAt(TypePath path) {
+  private TypeMention getMentionAt(TypePath path) {
     path.isEmpty() and
     result = this
     or
@@ -49,31 +49,25 @@ class SliceTypeReprMention extends TypeMention instanceof SliceTypeRepr {
   override Type resolveType() { result = TSliceType() }
 }
 
-class PathTypeReprMention extends TypeMention instanceof PathTypeRepr {
-  Path path;
-  ItemNode resolved;
+class PathTypeMention extends TypeMention, Path {
+  TypeItemNode resolved;
 
-  PathTypeReprMention() {
-    path = super.getPath() and
-    // NOTE: This excludes unresolvable paths which is intentional as these
-    // don't add value to the type inference anyway.
-    resolved = resolvePath(path)
-  }
+  PathTypeMention() { resolved = resolvePath(this) }
 
   ItemNode getResolved() { result = resolved }
 
   pragma[nomagic]
   private TypeAlias getResolvedTraitAlias(string name) {
     exists(TraitItemNode trait |
-      trait = resolvePath(path) and
+      trait = resolved and
       result = trait.getAnAssocItem() and
       name = result.getName().getText()
     )
   }
 
   pragma[nomagic]
   private TypeRepr getAssocTypeArg(string name) {
-    result = path.getSegment().getGenericArgList().getAssocTypeArg(name)
+    result = this.getSegment().getGenericArgList().getAssocTypeArg(name)
   }
 
   /** Gets the type argument for the associated type `alias`, if any. */
@@ -86,11 +80,11 @@ class PathTypeReprMention extends TypeMention instanceof PathTypeRepr {
   }
 
   override TypeMention getTypeArgument(int i) {
-    result = path.getSegment().getGenericArgList().getTypeArg(i)
+    result = this.getSegment().getGenericArgList().getTypeArg(i)
     or
     // If a type argument is not given in the path, then we use the default for
     // the type parameter if one exists for the type.
-    not exists(path.getSegment().getGenericArgList().getTypeArg(i)) and
+    not exists(this.getSegment().getGenericArgList().getTypeArg(i)) and
     result = this.resolveType().getTypeParameterDefault(i)
     or
     // `Self` paths inside `impl` blocks have implicit type arguments that are
@@ -106,7 +100,7 @@ class PathTypeReprMention extends TypeMention instanceof PathTypeRepr {
     //
     // the `Self` return type is shorthand for `Foo<T>`.
     exists(ImplItemNode node |
-      path = node.getASelfPath() and
+      this = node.getASelfPath() and
       result = node.(ImplItemNode).getSelfPath().getSegment().getGenericArgList().getTypeArg(i)
     )
     or
@@ -124,7 +118,7 @@ class PathTypeReprMention extends TypeMention instanceof PathTypeRepr {
     // ```
     // the rhs. of the type alias is a type argument to the trait.
     exists(ImplItemNode impl, AssociatedTypeTypeParameter param, TypeAlias alias |
-      path = impl.getTraitPath() and
+      this = impl.getTraitPath() and
       param.getTrait() = resolved and
       alias = impl.getASuccessor(param.getTypeAlias().getName().getText()) and
       result = alias.getTypeRepr() and
@@ -142,15 +136,15 @@ class PathTypeReprMention extends TypeMention instanceof PathTypeRepr {
    * resulting type at `typePath`.
    */
   pragma[nomagic]
-  Type aliasResolveTypeAt(TypePath typePath) {
+  private Type aliasResolveTypeAt(TypePath typePath) {
     exists(TypeAlias alias, TypeMention rhs | alias = resolved and rhs = alias.getTypeRepr() |
       result = rhs.resolveTypeAt(typePath) and
       not result = pathGetTypeParameter(alias, _)
       or
       exists(TypeParameter tp, TypeMention arg, TypePath prefix, TypePath suffix, int i |
         tp = rhs.resolveTypeAt(prefix) and
         tp = pathGetTypeParameter(alias, i) and
-        arg = path.getSegment().getGenericArgList().getTypeArg(i) and
+        arg = this.getSegment().getGenericArgList().getTypeArg(i) and
         result = arg.resolveTypeAt(suffix) and
         typePath = prefix.append(suffix)
       )
@@ -169,7 +163,7 @@ class PathTypeReprMention extends TypeMention instanceof PathTypeRepr {
       exists(TraitItemNode trait | trait = resolved |
         // If this is a `Self` path, then it resolves to the implicit `Self`
         // type parameter, otherwise it is a trait bound.
-        if super.getPath() = trait.getASelfPath()
+        if this = trait.getASelfPath()
         then result = TSelfTypeParameter(trait)
         else result = TTrait(trait)
       )
@@ -192,6 +186,18 @@ class PathTypeReprMention extends TypeMention instanceof PathTypeRepr {
   }
 }
 
+class PathTypeReprMention extends TypeMention, PathTypeRepr {
+  private PathTypeMention path;
+
+  PathTypeReprMention() { path = this.getPath() }
+
+  override TypeMention getTypeArgument(int i) { result = path.getTypeArgument(i) }
+
+  override Type resolveType() { result = path.resolveType() }
+
+  override Type resolveTypeAt(TypePath typePath) { result = path.resolveTypeAt(typePath) }
+}
+
 class ImplTraitTypeReprMention extends TypeMention instanceof ImplTraitTypeRepr {
   override TypeMention getTypeArgument(int i) { none() }
 
diff --git a/rust/ql/test/extractor-tests/generated/Path/CONSISTENCY/TypeInferenceConsistency.expected b/rust/ql/test/extractor-tests/generated/Path/CONSISTENCY/TypeInferenceConsistency.expected
@@ -0,0 +1,3 @@
+illFormedTypeMention
+| gen_path_type_repr.rs:6:14:6:20 | ...::Item |
+| gen_path_type_repr.rs:6:14:6:20 | ...::Item |
diff --git a/rust/ql/test/extractor-tests/macro-expansion/CONSISTENCY/PathResolutionConsistency.expected b/rust/ql/test/extractor-tests/macro-expansion/CONSISTENCY/PathResolutionConsistency.expected
@@ -1,7 +1,17 @@
 multipleCallTargets
+| proc_macro.rs:6:18:6:61 | ...::from(...) |
+| proc_macro.rs:7:15:7:58 | ...::from(...) |
+| proc_macro.rs:15:5:17:5 | ...::new(...) |
 | proc_macro.rs:16:12:16:16 | ...::to_tokens(...) |
+| proc_macro.rs:22:15:22:58 | ...::from(...) |
+| proc_macro.rs:25:5:28:5 | ...::new(...) |
 | proc_macro.rs:26:10:26:12 | ...::to_tokens(...) |
 | proc_macro.rs:27:10:27:16 | ...::to_tokens(...) |
+| proc_macro.rs:38:15:38:64 | ...::from(...) |
+| proc_macro.rs:41:5:49:5 | ...::new(...) |
+| proc_macro.rs:41:5:49:5 | ...::new(...) |
+| proc_macro.rs:41:5:49:5 | ...::new(...) |
+| proc_macro.rs:41:5:49:5 | ...::new(...) |
 | proc_macro.rs:42:16:42:26 | ...::to_tokens(...) |
 | proc_macro.rs:44:27:44:30 | ...::to_tokens(...) |
 | proc_macro.rs:46:18:46:28 | ...::to_tokens(...) |
diff --git a/rust/ql/test/extractor-tests/macro-expansion/CONSISTENCY/TypeInferenceConsistency.expected b/rust/ql/test/extractor-tests/macro-expansion/CONSISTENCY/TypeInferenceConsistency.expected
@@ -1,2 +1,3 @@
 illFormedTypeMention
 | macro_expansion.rs:99:7:99:19 | MyDeriveUnion |
+| macro_expansion.rs:99:7:99:19 | MyDeriveUnion |
diff --git a/rust/ql/test/library-tests/path-resolution/CONSISTENCY/PathResolutionConsistency.expected b/rust/ql/test/library-tests/path-resolution/CONSISTENCY/PathResolutionConsistency.expected
@@ -1,5 +1,8 @@
 multipleCallTargets
 | main.rs:118:9:118:11 | f(...) |
+| proc_macro.rs:6:16:6:59 | ...::from(...) |
+| proc_macro.rs:7:19:7:62 | ...::from(...) |
+| proc_macro.rs:9:5:11:5 | ...::new(...) |
 | proc_macro.rs:10:10:10:12 | ...::to_tokens(...) |
 multiplePathResolutions
 | main.rs:626:3:626:12 | proc_macro |
diff --git a/rust/ql/test/library-tests/type-inference/main.rs b/rust/ql/test/library-tests/type-inference/main.rs
@@ -792,7 +792,7 @@ mod method_supertraits {
             if 3 > 2 { // $ method=gt
                 self.m1() // $ method=MyTrait1::m1
             } else {
-                Self::m1(self)
+                Self::m1(self) // $ method=MyTrait1::m1
             }
         }
     }
@@ -806,7 +806,7 @@ mod method_supertraits {
             if 3 > 2 { // $ method=gt
                 self.m2().a // $ method=m2 $ fieldof=MyThing
             } else {
-                Self::m2(self).a // $ fieldof=MyThing
+                Self::m2(self).a // $ method=m2 fieldof=MyThing
             }
         }
     }
@@ -1024,7 +1024,7 @@ mod option_methods {
     struct S;
 
     pub fn f() {
-        let x1 = MyOption::<S>::new(); // $ MISSING: type=x1:T.S
+        let x1 = MyOption::<S>::new(); // $ type=x1:T.S
         println!("{:?}", x1);
 
         let mut x2 = MyOption::new();
@@ -1043,7 +1043,7 @@ mod option_methods {
         println!("{:?}", x5.flatten()); // $ method=flatten
 
         let x6 = MyOption::MySome(MyOption::<S>::MyNone());
-        println!("{:?}", MyOption::<MyOption<S>>::flatten(x6));
+        println!("{:?}", MyOption::<MyOption<S>>::flatten(x6)); // $ method=flatten
 
         #[rustfmt::skip]
         let from_if = if 3 > 2 { // $ method=gt
@@ -2068,10 +2068,10 @@ mod explicit_type_args {
 
     pub fn f() {
         let x1 : Option<S1<S2>> = S1::assoc_fun(); // $ type=x1:T.T.S2
-        let x2 = S1::<S2>::assoc_fun(); // $ MISSING: type=x2:T.T.S2
-        let x3 = S3::assoc_fun(); // $ MISSING: type=x3:T.T.S2
-        let x4 = S1::<S2>::method(S1::default()); // $ MISSING: method=method type=x4:T.S2
-        let x5 = S3::method(S1::default()); // $ MISSING: method=method type=x5:T.S2
+        let x2 = S1::<S2>::assoc_fun(); // $ type=x2:T.T.S2
+        let x3 = S3::assoc_fun(); // $ type=x3:T.T.S2
+        let x4 = S1::<S2>::method(S1::default()); // $ method=method type=x4:T.S2
+        let x5 = S3::method(S1::default()); // $ method=method type=x5:T.S2
         let x6 = S4::<S2>(S2); // $ type=x6:T4.S2
         let x7 = S4(S2); // $ type=x7:T4.S2
         let x8 = S4(0); // $ type=x8:T4.i32
diff --git a/rust/ql/test/library-tests/type-inference/type-inference.expected b/rust/ql/test/library-tests/type-inference/type-inference.expected
diff --git a/rust/ql/test/query-tests/security/CWE-327/CONSISTENCY/PathResolutionConsistency.expected b/rust/ql/test/query-tests/security/CWE-327/CONSISTENCY/PathResolutionConsistency.expected
diff --git a/rust/ql/test/query-tests/unusedentities/CONSISTENCY/TypeInferenceConsistency.expected b/rust/ql/test/query-tests/unusedentities/CONSISTENCY/TypeInferenceConsistency.expected

Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ module Impl {`
`67`	`67`	`}`
`68`	`68`	`}`
`69`	`69`
`70`		`- /** Holds if the call expression dispatches to a trait method. */`
	`70`	`+ /** Holds if the call expression dispatches to a method. */`
`71`	`71`	`private predicate callIsMethodCall(CallExpr call, Path qualifier, string methodName) {`
`72`	`72`	`exists(Path path, Function f \|`
`73`	`73`	`path = call.getFunction().(PathExpr).getPath() and`
Original file line number	Diff line number	Diff line change
`@@ -181,6 +181,9 @@ abstract class ItemNode extends Locatable {`
`181`	`181`	`result = this.(TypeParamItemNode).resolveABound().getASuccessorRec(name).(AssocItemNode)`
`182`	`182`	`or`
`183`	`183`	`result = this.(ImplTraitTypeReprItemNode).resolveABound().getASuccessorRec(name).(AssocItemNode)`
	`184`	`+ or`
	`185`	`+ result = this.(TypeAliasItemNode).resolveAlias().getASuccessorRec(name) and`
	`186`	`+ not result instanceof TypeParam`
`184`	`187`	`}`
`185`	`188`
`186`	`189`	`/**`
`@@ -289,6 +292,8 @@ abstract class ItemNode extends Locatable {`
`289`	`292`	`Location getLocation() { result = super.getLocation() }`
`290`	`293`	`}`
`291`	`294`
	`295`	`+abstract class TypeItemNode extends ItemNode { }`
	`296`	`+`
`292`	`297`	`/** A module or a source file. */`
`293`	`298`	`abstract private class ModuleLikeNode extends ItemNode {`
`294`	`299`	`/** Gets an item that may refer directly to items defined in this module. */`
`@@ -438,7 +443,7 @@ private class ConstItemNode extends AssocItemNode instanceof Const {`
`438`	`443`	`override TypeParam getTypeParam(int i) { none() }`
`439`	`444`	`}`
`440`	`445`
`441`		`-private class EnumItemNode extends ItemNode instanceof Enum {`
	`446`	`+private class EnumItemNode extends TypeItemNode instanceof Enum {`
`442`	`447`	`override string getName() { result = Enum.super.getName().getText() }`
`443`	`448`
`444`	`449`	`override Namespace getNamespace() { result.isType() }`
`@@ -739,7 +744,7 @@ private class ModuleItemNode extends ModuleLikeNode instanceof Module {`
`739`	`744`	`}`
`740`	`745`	`}`
`741`	`746`
`742`		`-private class StructItemNode extends ItemNode instanceof Struct {`
	`747`	`+private class StructItemNode extends TypeItemNode instanceof Struct {`
`743`	`748`	`override string getName() { result = Struct.super.getName().getText() }`
`744`	`749`
`745`	`750`	`override Namespace getNamespace() {`
`@@ -774,7 +779,7 @@ private class StructItemNode extends ItemNode instanceof Struct {`
`774`	`779`	`}`
`775`	`780`	`}`
`776`	`781`
`777`		`-class TraitItemNode extends ImplOrTraitItemNode instanceof Trait {`
	`782`	`+class TraitItemNode extends ImplOrTraitItemNode, TypeItemNode instanceof Trait {`
`778`	`783`	`pragma[nomagic]`
`779`	`784`	`Path getABoundPath() {`
`780`	`785`	`result = super.getTypeBoundList().getABound().getTypeRepr().(PathTypeRepr).getPath()`
`@@ -831,7 +836,10 @@ class TraitItemNode extends ImplOrTraitItemNode instanceof Trait {`
`831`	`836`	`}`
`832`	`837`	`}`
`833`	`838`
`834`		`-class TypeAliasItemNode extends AssocItemNode instanceof TypeAlias {`
	`839`	`+class TypeAliasItemNode extends TypeItemNode, AssocItemNode instanceof TypeAlias {`
	`840`	`+ pragma[nomagic]`
	`841`	`+ ItemNode resolveAlias() { result = resolvePathFull(super.getTypeRepr().(PathTypeRepr).getPath()) }`
	`842`	`+`
`835`	`843`	`override string getName() { result = TypeAlias.super.getName().getText() }`
`836`	`844`
`837`	`845`	`override predicate hasImplementation() { super.hasTypeRepr() }`
`@@ -847,7 +855,7 @@ class TypeAliasItemNode extends AssocItemNode instanceof TypeAlias {`
`847`	`855`	`override string getCanonicalPath(Crate c) { none() }`
`848`	`856`	`}`
`849`	`857`
`850`		`-private class UnionItemNode extends ItemNode instanceof Union {`
	`858`	`+private class UnionItemNode extends TypeItemNode instanceof Union {`
`851`	`859`	`override string getName() { result = Union.super.getName().getText() }`
`852`	`860`
`853`	`861`	`override Namespace getNamespace() { result.isType() }`
`@@ -905,7 +913,7 @@ private class BlockExprItemNode extends ItemNode instanceof BlockExpr {`
`905`	`913`	`override string getCanonicalPath(Crate c) { none() }`
`906`	`914`	`}`
`907`	`915`
`908`		`-class TypeParamItemNode extends ItemNode instanceof TypeParam {`
	`916`	`+class TypeParamItemNode extends TypeItemNode instanceof TypeParam {`
`909`	`917`	`private WherePred getAWherePred() {`
`910`	`918`	`exists(ItemNode declaringItem \|`
`911`	`919`	`this = resolveTypeParamPathTypeRepr(result.getTypeRepr()) and`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+illFormedTypeMention`
	`2`	`+\| gen_path_type_repr.rs:6:14:6:20 \| ...::Item \|`
	`3`	`+\| gen_path_type_repr.rs:6:14:6:20 \| ...::Item \|`
Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,3 @@`
`1`	`1`	`illFormedTypeMention`
`2`	`2`	`\| macro_expansion.rs:99:7:99:19 \| MyDeriveUnion \|`
	`3`	`+\| macro_expansion.rs:99:7:99:19 \| MyDeriveUnion \|`