Shared: Refactor type inference

Author: paldepind

shared/typeinference/codeql/typeinference/internal/TypeInference.qll

@@ -268,10 +268,8 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
     private module BaseTypes {
       /**
        * Holds if `baseMention` is a (transitive) base type mention of `sub`,
-       * and type parameter `tp` (belonging to `sub`) is mentioned (implicitly)
-       * at `path` inside the type that `baseMention` resolves to.
-       *
-       * For example, in
+       * and `t` is mentioned (implicitly) at `path` inside `baseMention`. For
+       * example, in
        *
        * ```csharp
        * class C<T1> { }
@@ -283,88 +281,21 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
        * class Sub<T4> : Mid<C<T4>> { } // Sub<T4> extends Base<C<C<T4>>
        * ```
        *
-       * - `T3` is mentioned at `0.0` for immediate base type mention `Base<C<T3>>`
+       * - ``C`1`` is mentioned at `T2` for immediate base type mention `Base<C<T3>>`
        *   of `Mid`,
-       * - `T4` is mentioned at `0.0` for immediate base type mention `Mid<C<T4>>`
-       *   of `Sub`, and
-       * - `T4` is mentioned implicitly at `0.0.0` for transitive base type mention
-       *   `Base<C<T3>>` of `Sub`.
-       */
-      pragma[nomagic]
-      predicate baseTypeMentionHasTypeParameterAt(
-        Type sub, TypeMention baseMention, TypePath path, TypeParameter tp
-      ) {
-        exists(TypeMention immediateBaseMention, TypePath pathToTypeParam |
-          tp = sub.getATypeParameter() and
-          immediateBaseMention = getABaseTypeMention(sub) and
-          tp = immediateBaseMention.resolveTypeAt(pathToTypeParam)
-        |
-          // immediate base class
-          baseMention = immediateBaseMention and
-          path = pathToTypeParam
-          or
-          // transitive base class
-          exists(Type immediateBase, TypePath prefix, TypePath suffix, TypeParameter mid |
-            /*
-             * Example:
-             *
-             * - `prefix = "0.0"`,
-             * - `pathToTypeParam = "0.0"`,
-             * - `suffix = "0"`,
-             * - `path = "0.0.0"`
-             *
-             * ```csharp
-             * class C<T1> { }
-             *
-             * class Base<T2> { }
-             *
-             * class Mid<T3> : Base<C<T3>> { }
-             * //    ^^^ `immediateBase`
-             * //        ^^ `mid`
-             * //              ^^^^^^^^^^^ `baseMention`
-             *
-             * class Sub<T4> : Mid<C<T4>> { }
-             * //    ^^^ `sub`
-             * //        ^^ `tp`
-             * //              ^^^^^^^^^^ `immediateBaseMention`
-             * ```
-             */
-
-            immediateBase = resolveTypeMentionRoot(immediateBaseMention) and
-            baseTypeMentionHasTypeParameterAt(immediateBase, baseMention, prefix, mid) and
-            pathToTypeParam.isCons(mid, suffix) and
-            path = prefix.append(suffix)
-          )
-        )
-      }
-
-      /**
-       * Holds if `baseMention` is a (transitive) base type mention of `sub`,
-       * and `t`, which is not a type parameter of `sub`, is mentioned
-       * (implicitly) at `path` inside `baseMention`. For example, in
-       *
-       * ```csharp
-       * class C<T1> { }
-       *
-       * class Base<T2> { }
-       *
-       * class Mid<T3> : Base<C<T3>> { }
-       *
-       * class Sub<T4> : Mid<C<T4>> { } // Sub<T4> extends Base<C<C<T4>>
-       * ```
-       *
-       * - ``C`1`` is mentioned at `0` for immediate base type mention `Base<C<T3>>`
+       * - `T3` is mentioned at `T2.T1` for immediate base type mention `Base<C<T3>>`
        *   of `Mid`,
-       * - ``C`1`` is mentioned at `0` for immediate base type mention `Mid<C<T4>>`
+       * - ``C`1`` is mentioned at `T3` for immediate base type mention `Mid<C<T4>>`
+       *   of `Sub`, and
+       * - `T4` is mentioned at `T3.T1` for immediate base type mention `Mid<C<T4>>`
        *   of `Sub`, and
-       * - ``C`1`` is mentioned at `0` and implicitly at `0.0` for transitive base type
+       * - ``C`1`` is mentioned at `T2` and implicitly at `T2.T1` for transitive base type
        *   mention `Base<C<T3>>` of `Sub`.
+       * - `T4` is mentioned implicitly at `T2.T1.T1` for transitive base type mention
+       *   `Base<C<T3>>` of `Sub`.
        */
       pragma[nomagic]
-      predicate baseTypeMentionHasNonTypeParameterAt(
-        Type sub, TypeMention baseMention, TypePath path, Type t
-      ) {
-        not t = sub.getATypeParameter() and
+      predicate baseTypeMentionHasTypeAt(Type sub, TypeMention baseMention, TypePath path, Type t) {
         exists(TypeMention immediateBaseMention |
           pragma[only_bind_into](immediateBaseMention) =
             getABaseTypeMention(pragma[only_bind_into](sub))
@@ -375,16 +306,17 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
           or
           // transitive base class
           exists(Type immediateBase | immediateBase = resolveTypeMentionRoot(immediateBaseMention) |
-            baseTypeMentionHasNonTypeParameterAt(immediateBase, baseMention, path, t)
+            not t = immediateBase.getATypeParameter() and
+            baseTypeMentionHasTypeAt(immediateBase, baseMention, path, t)
             or
             exists(TypePath path0, TypePath prefix, TypePath suffix, TypeParameter tp |
               /*
                * Example:
                *
-               * - `prefix = "0.0"`,
-               * - `path0 = "0"`,
+               * - `prefix = "T2.T1"`,
+               * - `path0 = "T3"`,
                * - `suffix = ""`,
-               * - `path = "0.0"`
+               * - `path = "T2.T1"`
                *
                * ```csharp
                * class C<T1> { }
@@ -403,7 +335,8 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
                * ```
                */
 
-              baseTypeMentionHasTypeParameterAt(immediateBase, baseMention, prefix, tp) and
+              baseTypeMentionHasTypeAt(immediateBase, baseMention, prefix, tp) and
+              tp = immediateBase.getATypeParameter() and
               t = immediateBaseMention.resolveTypeAt(path0) and
               path0.isCons(tp, suffix) and
               path = prefix.append(suffix)
@@ -578,22 +511,27 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
       }
 
       private module AccessBaseType {
-        private predicate relevantAccess(Access a, AccessPosition apos) {
-          exists(Declaration target |
-            adjustedAccessType(a, apos, target, _, _) and
-            target.getDeclaredType(_, _) instanceof TypeParameter
+        /**
+         * Holds if inferring types at `a` might depend on the type at `apos`
+         * having `baseMention` as a transitive base type mention.
+         */
+        private predicate relevantAccess(Access a, AccessPosition apos, TypeMention baseMention) {
+          exists(Declaration target, DeclarationPosition dpos |
+            a.getTarget() = target and
+            accessDeclarationPositionMatch(apos, dpos) and
+            declarationBaseType(target, dpos, baseMention, _, _)
           )
         }
 
         pragma[nomagic]
         private Type inferRootType(Access a, AccessPosition apos) {
-          relevantAccess(a, apos) and
+          relevantAccess(a, apos, _) and
           result = a.getInferredType(apos, TypePath::nil())
         }
 
         pragma[nomagic]
         private Type inferTypeAt(Access a, AccessPosition apos, TypeParameter tp, TypePath suffix) {
-          relevantAccess(a, apos) and
+          relevantAccess(a, apos, _) and
           exists(TypePath path0 |
             result = a.getInferredType(apos, path0) and
             path0.isCons(tp, suffix)
@@ -634,42 +572,33 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
         predicate hasBaseTypeMention(
           Access a, AccessPosition apos, TypeMention baseMention, TypePath path, Type t
         ) {
+          relevantAccess(a, apos, baseMention) and
           exists(Type sub | sub = inferRootType(a, apos) |
-            baseTypeMentionHasNonTypeParameterAt(sub, baseMention, path, t)
+            not t = sub.getATypeParameter() and
+            baseTypeMentionHasTypeAt(sub, baseMention, path, t)
             or
             exists(TypePath prefix, TypePath suffix, TypeParameter tp |
-              baseTypeMentionHasTypeParameterAt(sub, baseMention, prefix, tp) and
+              tp = sub.getATypeParameter() and
+              baseTypeMentionHasTypeAt(sub, baseMention, prefix, tp) and
               t = inferTypeAt(a, apos, tp, suffix) and
               path = prefix.append(suffix)
             )
           )
         }
       }
 
-      /**
-       * Holds if the type of `a` at `apos` has the base type `base`, and when
-       * viewed as an element of that type has the type `t` at `path`.
-       */
-      pragma[nomagic]
-      private predicate accessBaseType(
-        Access a, AccessPosition apos, Type base, TypePath path, Type t
-      ) {
-        exists(TypeMention tm |
-          AccessBaseType::hasBaseTypeMention(a, apos, tm, path, t) and
-          base = resolveTypeMentionRoot(tm)
-        )
-      }
-
       /**
        * Holds if the declared type at `decl` for `dpos` at the `path` is `tp`
        * and `path` starts with a type parameter of `base`.
        */
       pragma[nomagic]
       private predicate declarationBaseType(
-        Declaration decl, DeclarationPosition dpos, Type base, TypePath path, TypeParameter tp
+        Declaration decl, DeclarationPosition dpos, TypeMention base, TypePath path,
+        TypeParameter tp
       ) {
+        base = getABaseTypeMention(_) and
         tp = decl.getDeclaredType(dpos, path) and
-        path.isCons(base.getATypeParameter(), _)
+        path.isCons(resolveTypeMentionRoot(base).getATypeParameter(), _)
       }
 
       /**
@@ -710,8 +639,10 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
       ) {
         not exists(getTypeArgument(a, target, tp, _)) and
         target = a.getTarget() and
-        exists(AccessPosition apos, DeclarationPosition dpos, Type base, TypePath pathToTypeParam |
-          accessBaseType(a, apos, base, pathToTypeParam.append(path), t) and
+        exists(
+          AccessPosition apos, DeclarationPosition dpos, TypeMention base, TypePath pathToTypeParam
+        |
+          AccessBaseType::hasBaseTypeMention(a, apos, base, pathToTypeParam.append(path), t) and
           declarationBaseType(target, dpos, base, pathToTypeParam, tp) and
           accessDeclarationPositionMatch(apos, dpos)
         )