dbg3

Author: hvitved

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

@@ -165,7 +165,8 @@ abstract class ItemNode extends Locatable {
     exists(ItemNode node |
       this = node.(ImplItemNode).resolveSelfTy() and
       result = node.getASuccessorRec(name) and
-      result instanceof AssocItemNode
+      result instanceof AssocItemNode and
+      not result instanceof TypeAlias
     )
     or
     // trait items with default implementations made available in an implementation

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

@@ -7,56 +7,46 @@ private import TypeInference
 
 /** An AST node that may mention a type. */
 abstract class TypeMention extends AstNode {
-  /** Gets the `i`th type argument mention, if any. */
-  abstract TypeMention getTypeArgument(int i);
+  /** Gets the type at `path` that this mention resolves to, if any. */
+  abstract Type resolveTypeAt(TypePath path);
 
-  /** Gets the type that this node resolves to, if any. */
-  abstract Type resolveType();
+  final Type resolveType() { result = this.resolveTypeAt(TypePath::nil()) }
+}
 
-  // /** Gets the sub mention at `path`. */
-  // pragma[nomagic]
-  // private TypeMention getMentionAt(TypePath path) {
-  //   path.isEmpty() and
-  //   result = this
-  //   or
-  //   exists(int i, TypeParameter tp, TypeMention arg, TypePath suffix |
-  //     arg = this.getTypeArgument(pragma[only_bind_into](i)) and
-  //     result = arg.getMentionAt(suffix) and
-  //     path = TypePath::cons(tp, suffix) and
-  //     tp = this.resolveType().getTypeParameter(pragma[only_bind_into](i))
-  //   )
-  // }
-  /** Gets the type that the sub mention at `path` resolves to, if any. */
-  Type resolveTypeAt(TypePath path) {
+class ArrayTypeReprMention extends TypeMention instanceof ArrayTypeRepr {
+  override Type resolveTypeAt(TypePath path) {
     path.isEmpty() and
-    result = this.resolveType()
+    result = TArrayType()
     or
-    exists(int i, TypeParameter tp, TypeMention arg, TypePath suffix |
-      arg = this.getTypeArgument(pragma[only_bind_into](i)) and
-      result = arg.resolveTypeAt(suffix) and
-      path = TypePath::cons(tp, suffix) and
-      tp = this.resolveType().getTypeParameter(pragma[only_bind_into](i))
+    exists(TypePath suffix |
+      result = super.getElementTypeRepr().(TypeMention).resolveTypeAt(suffix) and
+      path = TypePath::cons(TArrayTypeParameter(), suffix)
     )
   }
-  // result = this.getMentionAt(path).resolveType() }
-}
-
-class ArrayTypeReprMention extends TypeMention instanceof ArrayTypeRepr {
-  override TypeMention getTypeArgument(int i) { result = super.getElementTypeRepr() and i = 0 }
-
-  override Type resolveType() { result = TArrayType() }
 }
 
 class RefTypeReprMention extends TypeMention instanceof RefTypeRepr {
-  override TypeMention getTypeArgument(int i) { result = super.getTypeRepr() and i = 0 }
-
-  override Type resolveType() { result = TRefType() }
+  override Type resolveTypeAt(TypePath path) {
+    path.isEmpty() and
+    result = TRefType()
+    or
+    exists(TypePath suffix |
+      result = super.getTypeRepr().(TypeMention).resolveTypeAt(suffix) and
+      path = TypePath::cons(TRefTypeParameter(), suffix)
+    )
+  }
 }
 
 class SliceTypeReprMention extends TypeMention instanceof SliceTypeRepr {
-  override TypeMention getTypeArgument(int i) { result = super.getTypeRepr() and i = 0 }
-
-  override Type resolveType() { result = TSliceType() }
+  override Type resolveTypeAt(TypePath path) {
+    path.isEmpty() and
+    result = TSliceType()
+    or
+    exists(TypePath suffix |
+      result = super.getTypeRepr().(TypeMention).resolveTypeAt(suffix) and
+      path = TypePath::cons(TSliceTypeParameter(), suffix)
+    )
+  }
 }
 
 class PathTypeMention extends TypeMention, Path {
@@ -89,15 +79,9 @@ class PathTypeMention extends TypeMention, Path {
     )
   }
 
-  override TypeMention getTypeArgument(int i) {
+  private TypeMention getTypeArgument0(int 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(this.getSegment().getGenericArgList().getTypeArg(i)) and
-    result = this.resolveType().getTypeParameterDefault(i) and
-    this = any(PathTypeRepr ptp).getPath().getQualifier*()
-    or
     // `Self` paths inside `impl` blocks have implicit type arguments that are
     // the type parameters of the `impl` block. For example, in
     //
@@ -114,6 +98,16 @@ class PathTypeMention extends TypeMention, Path {
       this = node.getASelfPath() and
       result = node.(ImplItemNode).getSelfPath().getSegment().getGenericArgList().getTypeArg(i)
     )
+  }
+
+  private TypeMention getTypeArgument(int i) {
+    result = this.getTypeArgument0(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(this.getTypeArgument0(i)) and
+    result = this.resolveType().getTypeParameterDefault(i) and
+    this = any(PathTypeRepr ptp).getPath().getQualifier*()
     or
     // If `path` is the trait of an `impl` block then any associated types
     // defined in the `impl` block are type arguments to the trait.
@@ -154,18 +148,18 @@ class PathTypeMention extends TypeMention, Path {
       or
       exists(TypeParameter tp, TypeMention arg, TypePath prefix, TypePath suffix, int i |
         tp = rhs.resolveTypeAt(prefix) and
-        tp = pathGetTypeParameter(alias, i) and
-        arg = this.getSegment().getGenericArgList().getTypeArg(i) and
+        tp = pathGetTypeParameter(alias, pragma[only_bind_into](i)) and
+        arg = this.getSegment().getGenericArgList().getTypeArg(pragma[only_bind_into](i)) and
         result = arg.resolveTypeAt(suffix) and
         typePath = prefix.append(suffix)
       )
     )
   }
 
-  override Type resolveType() {
-    result = this.aliasResolveTypeAt(TypePath::nil())
+  override Type resolveTypeAt(TypePath typePath) {
+    result = this.aliasResolveTypeAt(typePath)
     or
-    not exists(resolved.(TypeAlias).getTypeRepr()) and
+    typePath.isEmpty() and
     (
       result = TStruct(resolved)
       or
@@ -181,19 +175,19 @@ class PathTypeMention extends TypeMention, Path {
       or
       result = TTypeParamTypeParameter(resolved)
       or
-      exists(TypeAlias alias | alias = resolved |
+      exists(TypeAlias alias |
+        alias = resolved and
         result.(AssociatedTypeTypeParameter).getTypeAlias() = alias
-        or
-        result = alias.getTypeRepr().(TypeMention).resolveType()
       )
     )
-  }
-
-  override Type resolveTypeAt(TypePath typePath) {
-    result = this.aliasResolveTypeAt(typePath)
     or
     not exists(resolved.(TypeAlias).getTypeRepr()) and
-    result = super.resolveTypeAt(typePath)
+    exists(int i, TypeParameter tp, TypeMention arg, TypePath suffix |
+      arg = this.getTypeArgument(pragma[only_bind_into](i)) and
+      result = arg.resolveTypeAt(suffix) and
+      typePath = TypePath::cons(tp, suffix) and
+      tp = this.resolveType().getTypeParameter(pragma[only_bind_into](i))
+    )
   }
 }
 
@@ -202,17 +196,14 @@ class PathTypeReprMention extends TypeMention, PathTypeRepr {
 
   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() }
-
-  override ImplTraitType resolveType() { result.getImplTraitTypeRepr() = this }
+  override Type resolveTypeAt(TypePath typePath) {
+    typePath.isEmpty() and
+    result.(ImplTraitType).getImplTraitTypeRepr() = this
+  }
 }
 
 private TypeParameter pathGetTypeParameter(TypeAlias alias, int i) {
@@ -222,30 +213,44 @@ private TypeParameter pathGetTypeParameter(TypeAlias alias, int i) {
 // Used to represent implicit `Self` type arguments in traits and `impl` blocks,
 // see `PathMention` for details.
 class TypeParamMention extends TypeMention instanceof TypeParam {
-  override TypeMention getTypeArgument(int i) { none() }
-
-  override Type resolveType() { result = TTypeParamTypeParameter(this) }
+  override Type resolveTypeAt(TypePath typePath) {
+    typePath.isEmpty() and
+    result = TTypeParamTypeParameter(this)
+  }
 }
 
+// TODO: Remove?
 // Used to represent implicit type arguments for associated types in traits.
 class TypeAliasMention extends TypeMention instanceof TypeAlias {
   private Type t;
 
   TypeAliasMention() { t = TAssociatedTypeTypeParameter(this) }
 
-  override TypeMention getTypeArgument(int i) { none() }
-
-  override Type resolveType() { result = t }
+  override Type resolveTypeAt(TypePath typePath) {
+    typePath.isEmpty() and
+    result = t
+  }
+  // override TypeMention getTypeArgument(int i) { none() }
+  // override Type resolveType() { result = t }
 }
 
 class TraitMention extends TypeMention instanceof TraitItemNode {
-  override TypeMention getTypeArgument(int i) {
-    result = super.getTypeParam(i)
+  override Type resolveTypeAt(TypePath typePath) {
+    typePath.isEmpty() and
+    result = TTrait(this)
     or
-    traitAliasIndex(this, i, result)
+    exists(TypeAlias alias |
+      traitAliasIndex(this, _, alias) and
+      typePath = TypePath::singleton(result) and
+      result = TAssociatedTypeTypeParameter(alias)
+    )
+    or
+    exists(TypeParam tp |
+      tp = super.getTypeParam(_) and
+      typePath = TypePath::singleton(result) and
+      result = TTypeParamTypeParameter(tp)
+    )
   }
-
-  override Type resolveType() { result = TTrait(this) }
 }
 
 // NOTE: Since the implicit type parameter for the self type parameter never
@@ -259,7 +264,8 @@ class SelfTypeParameterMention extends TypeMention instanceof Name {
 
   Trait getTrait() { result = trait }
 
-  override Type resolveType() { result = TSelfTypeParameter(trait) }
-
-  override TypeMention getTypeArgument(int i) { none() }
+  override Type resolveTypeAt(TypePath typePath) {
+    typePath.isEmpty() and
+    result = TSelfTypeParameter(trait)
+  }
 }