wip5

Author: hvitved

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

@@ -284,8 +284,6 @@ private module Input3 implements InputSig3 {
     (exists(resolveTupleFieldExpr(_, _)) implies any())
   }
 
-  predicate inferType = M3::inferType/2;
-
   class BoolType extends DataType {
     BoolType() { this.getTypeItem() instanceof Builtins::Bool }
   }
@@ -480,22 +478,25 @@ private module Input3 implements InputSig3 {
       )
     or
     exists(CallExprImpl::DynamicCallExpr dce, TupleType tt, int i |
+      n1 = dce.getSyntacticPositionalArgument(i) and
       n2 = dce.getArgList() and
       tt.getArity() = dce.getNumberOfSyntacticArguments() and
-      n1 = dce.getSyntacticPositionalArgument(i) and
-      path2 = TypePath::singleton(tt.getPositionalTypeParameter(i)) and
-      path1.isEmpty()
+      path1.isEmpty() and
+      path2 = TypePath::singleton(tt.getPositionalTypeParameter(i))
     )
     or
     exists(ClosureExpr ce, int index |
-      n2 = ce and
       n1 = ce.getParam(index).getPat() and
-      path2 = closureParameterPath(ce.getNumberOfParams(), index) and
-      path1.isEmpty()
+      n2 = ce and
+      path1.isEmpty() and
+      path2 = closureParameterPath(ce.getNumberOfParams(), index)
     )
   }
 
-  Type inferTypeCertainSpecific(AstNode n, TypePath path) {
+  pragma[inline]
+  Type inferTypeCertain(AstNode n, TypePath path) {
+    result = M3::inferTypeCertain(n, path)
+    or
     result = inferLiteralType(n, path, true)
     or
     result = inferRefPatType(n) and
@@ -539,55 +540,64 @@ private module Input3 implements InputSig3 {
     path2.isEmpty()
     or
     n2 = any(ClosureExpr ce | not ce.hasRetType() and ce.getClosureBody() = n1) and
-    path2 = closureReturnPath() and
-    path1.isEmpty()
+    path1.isEmpty() and
+    path2 = closureReturnPath()
     or
     path1.isEmpty() and
     (
       n1 = n2.(ArrayListExpr).getAnExpr() and
       path2 = TypePath::singleton(getArrayTypeParameter())
       or
-      exists(ReturnExpr re, Rust::Callable c |
-        n1 = re.getExpr() and
-        c = re.getEnclosingCallable() and
-        n2 = c.getBody() and
-        path2.isEmpty()
-      )
-      or
       exists(Struct s |
         n1 = [n2.(RangeExpr).getStart(), n2.(RangeExpr).getEnd()] and
         path2 =
           TypePath::singleton(TTypeParamTypeParameter(s.getGenericParamList().getATypeParam())) and
         s = getRangeType(n2)
       )
-    )
-    or
-    path1.isEmpty() and
-    path2.isEmpty() and
-    (
-      n2 = n1.(OrPat).getAPat()
-      or
-      n2 = n1.(ParenPat).getPat()
       or
-      n2 = n1.(LiteralPat).getLiteral()
+      n2 =
+        any(RefExpr re |
+          n1 = re.getExpr() and
+          path2 = TypePath::singleton(inferRefExprType(re).getPositionalTypeParameter(0))
+        )
       or
-      exists(BreakExpr break |
-        break.getExpr() = n1 and
-        break.getTarget() = n2.(LoopExpr)
+      exists(BlockExpr be |
+        n2 = be and
+        n1 = be.getStmtList().getTailExpr() and
+        if be.isAsync()
+        then path2 = TypePath::singleton(getDynFutureOutputTypeParameter())
+        else path2.isEmpty()
       )
       or
-      n1 = n2.(MacroExpr).getMacroCall().getMacroCallExpansion() and
-      not isPanicMacroCall(n2)
+      // an array repeat expression (`[1; 3]`) has the type of the repeat operand
+      n2.(ArrayRepeatExpr).getRepeatOperand() = n1 and
+      path2 = TypePath::singleton(getArrayTypeParameter())
       or
-      n1 = n2.(MacroPat).getMacroCall().getMacroCallExpansion()
-    )
-    or
-    n2 =
-      any(RefExpr re |
-        n1 = re.getExpr() and
-        path1.isEmpty() and
-        path2 = TypePath::singleton(inferRefExprType(re).getPositionalTypeParameter(0))
+      path2.isEmpty() and
+      (
+        exists(ReturnExpr re, Rust::Callable c |
+          n1 = re.getExpr() and
+          c = re.getEnclosingCallable() and
+          n2 = c.getBody()
+        )
+        or
+        n2 = n1.(OrPat).getAPat()
+        or
+        n2 = n1.(ParenPat).getPat()
+        or
+        n2 = n1.(LiteralPat).getLiteral()
+        or
+        exists(BreakExpr break |
+          break.getExpr() = n1 and
+          break.getTarget() = n2.(LoopExpr)
+        )
+        or
+        n1 = n2.(MacroExpr).getMacroCall().getMacroCallExpansion() and
+        not isPanicMacroCall(n2)
+        or
+        n1 = n2.(MacroPat).getMacroCall().getMacroCallExpansion()
       )
+    )
     or
     n1 =
       any(RefPat rp |
@@ -611,24 +621,6 @@ private module Input3 implements InputSig3 {
       path2.isEmpty() and
       path1 = path
     )
-    or
-    exists(BlockExpr be |
-      n2 = be and
-      n1 = be.getStmtList().getTailExpr() and
-      if be.isAsync()
-      then
-        path2 = TypePath::singleton(getDynFutureOutputTypeParameter()) and
-        path1.isEmpty()
-      else (
-        path1.isEmpty() and
-        path2.isEmpty()
-      )
-    )
-    or
-    // an array repeat expression (`[1; 3]`) has the type of the repeat operand
-    n2.(ArrayRepeatExpr).getRepeatOperand() = n1 and
-    path2 = TypePath::singleton(getArrayTypeParameter()) and
-    path1.isEmpty()
   }
 
   Type inferTypeTopDown(AstNode n, TypePath path) {
@@ -645,9 +637,9 @@ private module Input3 implements InputSig3 {
     result = inferFieldExprType(n, path, true)
   }
 
-  Type inferTypeSpecific(AstNode n, TypePath path) {
-    // result = inferTypeCertainSpecific0(n, path)
-    // or
+  Type inferType(AstNode n, TypePath path) {
+    result = M3::inferType(n, path)
+    or
     isPanicMacroCall(n) and
     path.isEmpty() and
     result instanceof UnknownType
@@ -684,7 +676,6 @@ private module Input3 implements InputSig3 {
 
 private module M3 = Make3<Input3>;
 
-// import M3
 predicate inferType = M3::inferType/1;
 
 predicate inferType = M3::inferType/2;
@@ -693,23 +684,6 @@ predicate inferTypeCertain = M3::inferTypeCertain/2;
 
 module Consistency = M3::Consistency;
 
-// {
-//   import M2::Consistency
-//   private Type inferTypeCertainAdj(AstNode n, TypePath path) {
-//     result = inferTypeCertain(n, path) and
-//     not result = TUnknownType()
-//   }
-//   predicate nonUniqueCertainType(AstNode n, TypePath path, Type t) {
-//     strictcount(inferTypeCertainAdj(n, path)) > 1 and
-//     t = inferTypeCertainAdj(n, path) and
-//     // Suppress the inconsistency if `n` is a self parameter and the type
-//     // mention for the self type has multiple types for a path.
-//     not exists(ImplItemNode impl, TypePath selfTypePath |
-//       n = impl.getAnAssocItem().(Function).getSelfParam() and
-//       strictcount(impl.(Impl).getSelfTy().(TypeMention).getTypeAt(selfTypePath)) > 1
-//     )
-//   }
-// }
 /** A function without a `self` parameter. */
 private class NonMethodFunction extends Function {
   NonMethodFunction() { not this.hasSelfParam() }

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

@@ -1361,6 +1361,14 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
     module MatchingWithEnvironment<MatchingWithEnvironmentInputSig Input> {
       private import Input
 
+      pragma[nomagic]
+      private TypeParameter getDeclTypeParameter(Declaration decl, TypeArgumentPosition tapos) {
+        exists(TypeParameterPosition tppos |
+          result = decl.getTypeParameter(tppos) and
+          typeArgumentParameterPositionMatch(tapos, tppos)
+        )
+      }
+
       /**
        * Gets the type of the type argument at `path` in `a` that corresponds to
        * the type parameter `tp` in `target`, if any.
@@ -1372,10 +1380,9 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
       bindingset[a, target]
       pragma[inline_late]
       private Type getTypeArgument(Access a, Declaration target, TypeParameter tp, TypePath path) {
-        exists(TypeArgumentPosition tapos, TypeParameterPosition tppos |
+        exists(TypeArgumentPosition tapos |
           result = a.getTypeArgument(tapos, path) and
-          tp = target.getTypeParameter(tppos) and
-          typeArgumentParameterPositionMatch(tapos, tppos) and
+          tp = getDeclTypeParameter(target, tapos) and
           not result instanceof UnknownType //and path.isEmpty())
         )
       }
@@ -2036,13 +2043,6 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
        */
       default predicate cacheRevRef() { none() }
 
-      /**
-       * Point this predicate to the `inferType` predicate from the output of this module.
-       *
-       * Needed to be able to refer to `inferType` in default signature implementations.
-       */
-      Type inferType(AstNode n, TypePath path);
-
       /** A boolean type. */
       class BoolType extends Type;
 
@@ -2293,9 +2293,10 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
       /**
        * Gets the inferred certain type of `n` at `path`.
        *
-       * This predicate will be included directly in the exposed `inferTypeCertain` predicate.
+       * This predicate should include the `inferTypeCertain` predicate from the
+       * output of this module, as well as any language-specific additions.
        */
-      default Type inferTypeCertainSpecific(AstNode n, TypePath path) { none() }
+      Type inferTypeCertain(AstNode n, TypePath path);
 
       /**
        * Holds if `n1` having type `t` at `path1` implies that `n2` has type `t` at `path2`,
@@ -2304,19 +2305,20 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
       predicate inferStep(AstNode n1, TypePath path1, AstNode n2, TypePath path2);
 
       /**
-       * Gets the top-down inferred type of `n` at `path`.
+       * Gets the inferred certain type of `n` at `path`.
        *
-       * Type information is only propagated into nodes with an explicitly unknown
-       * type.
+       * This predicate should include the `inferType` predicate from the output of this module,
+       * as well as any language-specific additions.
        */
-      default Type inferTypeTopDown(AstNode n, TypePath path) { none() }
+      Type inferType(AstNode n, TypePath path);
 
       /**
-       * Gets the inferred type of `n` at `path`.
+       * Gets the top-down inferred type of `n` at `path`.
        *
-       * This predicate will be included directly in the exposed `inferType` predicate.
+       * Type information is only propagated into nodes with an explicitly unknown
+       * type.
        */
-      Type inferTypeSpecific(AstNode n, TypePath path);
+      default Type inferTypeTopDown(AstNode n, TypePath path) { none() }
     }
 
     module Make3<InputSig3 Input3> {
@@ -2371,12 +2373,12 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
         Type inferTypeCertain(AstNode n, TypePath path) {
           (
             CachedStage::ref() and
+            result = Input3::inferTypeCertain(n, path)
+            or
             result = inferAnnotatedType(n, path)
             or
             result = inferTypeFromStepCertain(n, path)
             or
-            result = inferTypeCertainSpecific(n, path)
-            or
             result = inferLogicalOperationType(n, path)
             or
             infersCertainTypeAt(n, path, result.getATypeParameter())
@@ -2403,6 +2405,7 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
         private predicate infersCertainTypeAt(AstNode n, TypePath prefix, TypeParameter tp) {
           exists(TypePath path |
             hasInferredCertainType(n, path) and
+            not path.isEmpty() and // implied by `isSnoc` below, but improves performance slightly
             path.isSnoc(prefix, tp)
           )
         }
@@ -2481,6 +2484,8 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
       }
 
       private Type inferType0(AstNode n, TypePath path) {
+        result = Input3::inferType(n, path)
+        or
         result = inferAnnotatedType(n, path)
         or
         exists(LocalVariableDeclaration decl |
@@ -2499,8 +2504,6 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
         result = TopDownTyping<inferCallArgumentTypeTopDown/2>::inferType(n, path)
         or
         result = TopDownTyping<inferTypeTopDown/2>::inferType(n, path)
-        or
-        result = inferTypeSpecific(n, path)
       }
 
       /**
@@ -2521,26 +2524,26 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
           not Certain::certainTypeConflict(n, prefix, path, result)
         )
         or
-        hasUnknownCertainTypeAt(n, path) and
-        result instanceof UnknownType
-        or
-        infersTypeAt(n, path, result.getATypeParameter())
-      }
-
-      private predicate hasUnknownCertainTypeAt(AstNode n, TypePath path) {
+        // If `n` has an explicitly unknown type at `prefix` and at the same time a certain
+        // type at `prefix.suffix`, then extend the unknown type information to any path
+        // extending `prefix.suffix` where there is no certain type information
         exists(TypePath prefix, TypePath suffix, Type certain, TypeParameter tp |
           inferType0(n, prefix) instanceof UnknownType and
           certain = inferTypeCertain(n, prefix.appendInverse(suffix)) and
           tp = certain.getATypeParameter() and
           path = prefix.append(suffix).append(TypePath::singleton(tp)) and
-          not exists(inferTypeCertain(n, path))
+          not exists(inferTypeCertain(n, path)) and
+          result instanceof UnknownType
         )
+        or
+        infersTypeAt(n, path, result.getATypeParameter())
       }
 
       pragma[nomagic]
       private predicate infersTypeAt(AstNode n, TypePath prefix, TypeParameter tp) {
         exists(TypePath path |
           exists(inferType(n, path)) and
+          not path.isEmpty() and // implied by `isSnoc` below, but improves performance slightly
           path.isSnoc(prefix, tp)
         )
       }