Rust: Move TypeAbstraction into separate file

Author: paldepind

rust/ql/lib/codeql/rust/internal/typeinference/FunctionOverloading.qll

@@ -8,6 +8,7 @@
 private import rust
 private import codeql.rust.internal.PathResolution
 private import Type
+private import TypeAbstraction
 private import TypeMention
 private import TypeInference
 private import FunctionType

rust/ql/lib/codeql/rust/internal/typeinference/FunctionType.qll

@@ -1,8 +1,9 @@
 private import rust
 private import codeql.rust.internal.PathResolution
-private import TypeInference
 private import Type
+private import TypeAbstraction
 private import TypeMention
+private import TypeInference
 
 private newtype TFunctionPosition =
   TArgumentFunctionPosition(ArgumentPosition pos) or

rust/ql/lib/codeql/rust/internal/typeinference/Type.qll

@@ -569,74 +569,6 @@ class ImplTraitTypeTypeParameter extends ImplTraitType, TypeParameter {
   override TypeParameter getPositionalTypeParameter(int i) { none() }
 }
 
-/**
- * A type abstraction. I.e., a place in the program where type variables are
- * introduced.
- *
- * Example:
- * ```rust
- * impl<A, B> Foo<A, B> { }
- * //  ^^^^^^ a type abstraction
- * ```
- */
-abstract class TypeAbstraction extends AstNode {
-  abstract TypeParameter getATypeParameter();
-}
-
-final class ImplTypeAbstraction extends TypeAbstraction, Impl {
-  override TypeParamTypeParameter getATypeParameter() {
-    result.getTypeParam() = this.getGenericParamList().getATypeParam()
-  }
-}
-
-private predicate idDynTraitTypeRepr(@dyn_trait_type_repr x, @dyn_trait_type_repr y) { x = y }
-
-private predicate idOfDynTraitTypeRepr(@dyn_trait_type_repr x, int y) =
-  equivalenceRelation(idDynTraitTypeRepr/2)(x, y)
-
-private int idOfDynTraitTypeRepr(DynTraitTypeRepr node) {
-  idOfDynTraitTypeRepr(Synth::convertAstNodeToRaw(node), result)
-}
-
-/** Holds if `dt` is the canonical dyn trait type abstraction for `trait`. */
-private predicate canonicalDynTraitTypeAbstraction(DynTraitTypeRepr dt, Trait trait) {
-  dt = min(DynTraitTypeRepr d | d.getTrait() = trait | d order by idOfDynTraitTypeRepr(d))
-}
-
-final class DynTypeAbstraction extends TypeAbstraction, DynTraitTypeRepr {
-  DynTypeAbstraction() { canonicalDynTraitTypeAbstraction(this, this.getTrait()) }
-
-  override TypeParameter getATypeParameter() {
-    result = any(DynTraitTypeParameter tp | tp.getTrait() = this.getTrait()).getTraitTypeParameter()
-  }
-}
-
-final class TraitTypeAbstraction extends TypeAbstraction, Trait {
-  override TypeParameter getATypeParameter() {
-    result.(TypeParamTypeParameter).getTypeParam() = this.getGenericParamList().getATypeParam()
-    or
-    result.(AssociatedTypeTypeParameter).getTrait() = this
-    or
-    result.(SelfTypeParameter).getTrait() = this
-  }
-}
-
-final class TypeBoundTypeAbstraction extends TypeAbstraction, TypeBound {
-  override TypeParameter getATypeParameter() { none() }
-}
-
-final class SelfTypeBoundTypeAbstraction extends TypeAbstraction, Name {
-  SelfTypeBoundTypeAbstraction() { any(TraitTypeAbstraction trait).getName() = this }
-
-  override TypeParameter getATypeParameter() { none() }
-}
-
-final class ImplTraitTypeReprAbstraction extends TypeAbstraction, ImplTraitTypeRepr {
-  override TypeParameter getATypeParameter() {
-    implTraitTypeParam(this, _, result.(TypeParamTypeParameter).getTypeParam())
-  }
-}
-
 /**
  * Holds if `t` is a valid complex [`self` root type][1].
  *

rust/ql/lib/codeql/rust/internal/typeinference/TypeAbstraction.qll

@@ -0,0 +1,56 @@
+private import rust
+private import codeql.rust.elements.internal.generated.Raw
+private import codeql.rust.elements.internal.generated.Synth
+private import Type
+
+/**
+ * A type abstraction. I.e., a place in the program where type variables are
+ * introduced.
+ *
+ * Example:
+ * ```rust
+ * impl<A, B> Foo<A, B> { }
+ * //  ^^^^^^ a type abstraction
+ * ```
+ */
+abstract class TypeAbstraction extends AstNode {
+  abstract TypeParameter getATypeParameter();
+}
+
+final class ImplTypeAbstraction extends TypeAbstraction, Impl {
+  override TypeParamTypeParameter getATypeParameter() {
+    result.getTypeParam() = this.getGenericParamList().getATypeParam()
+  }
+}
+
+final class DynTypeAbstraction extends TypeAbstraction, DynTraitTypeRepr {
+  override TypeParameter getATypeParameter() {
+    result = any(DynTraitTypeParameter tp | tp.getTrait() = this.getTrait()).getTraitTypeParameter()
+  }
+}
+
+final class TraitTypeAbstraction extends TypeAbstraction, Trait {
+  override TypeParameter getATypeParameter() {
+    result.(TypeParamTypeParameter).getTypeParam() = this.getGenericParamList().getATypeParam()
+    or
+    result.(AssociatedTypeTypeParameter).getTrait() = this
+    or
+    result.(SelfTypeParameter).getTrait() = this
+  }
+}
+
+final class TypeBoundTypeAbstraction extends TypeAbstraction, TypeBound {
+  override TypeParameter getATypeParameter() { none() }
+}
+
+final class SelfTypeBoundTypeAbstraction extends TypeAbstraction, Name {
+  SelfTypeBoundTypeAbstraction() { any(TraitTypeAbstraction trait).getName() = this }
+
+  override TypeParameter getATypeParameter() { none() }
+}
+
+final class ImplTraitTypeReprAbstraction extends TypeAbstraction, ImplTraitTypeRepr {
+  override TypeParamTypeParameter getATypeParameter() {
+    exists(TImplTraitTypeParameter(this, result.getTypeParam()))
+  }
+}

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

@@ -5,6 +5,8 @@ private import codeql.util.Option
 private import rust
 private import codeql.rust.internal.PathResolution
 private import Type
+private import TypeAbstraction
+private import TypeAbstraction as TA
 private import Type as T
 private import TypeMention
 private import codeql.rust.internal.typeinference.DerefChain
@@ -37,7 +39,7 @@ private module Input1 implements InputSig1<Location> {
 
   class TypeParameter = T::TypeParameter;
 
-  class TypeAbstraction = T::TypeAbstraction;
+  class TypeAbstraction = TA::TypeAbstraction;
 
   class TypeArgumentPosition extends TTypeArgumentPosition {
     int asMethodTypeArgumentPosition() { this = TMethodTypeArgumentPosition(result) }