wip

Author: hvitved

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

@@ -3,7 +3,6 @@
 private import rust
 private import codeql.rust.internal.PathResolution
 private import TypeMention
-private import TypeInference
 private import codeql.rust.internal.CachedStages
 private import codeql.rust.elements.internal.generated.Raw
 private import codeql.rust.elements.internal.generated.Synth

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

@@ -276,12 +276,6 @@ private Type inferStructPatType(StructPat sp, TypePath path) {
   result = sp.getPath().(TypeMention).getTypeAt(path)
 }
 
-private Type inferAssignmentOperationType(AstNode n, TypePath path) {
-  n instanceof AssignmentOperation and
-  path.isEmpty() and
-  result instanceof UnitType
-}
-
 pragma[nomagic]
 private Struct getRangeType(RangeExpr re) {
   re instanceof RangeFromExpr and
@@ -290,9 +284,6 @@ private Struct getRangeType(RangeExpr re) {
   re instanceof RangeToExpr and
   result instanceof RangeToStruct
   or
-  re instanceof RangeFullExpr and
-  result instanceof RangeFullStruct
-  or
   re instanceof RangeFromToExpr and
   result instanceof RangeStruct
   or
@@ -1972,30 +1963,28 @@ predicate isUnitBlockExpr(BlockExpr be) {
 }
 
 pragma[nomagic]
-private Type inferBlockExprType(BlockExpr be, TypePath path) {
-  // `typeEquality` handles the non-root case
-  if be instanceof AsyncBlockExpr
-  then (
-    path.isEmpty() and
-    result = getFutureTraitType()
-    or
-    isUnitBlockExpr(be) and
-    path = TypePath::singleton(getDynFutureOutputTypeParameter()) and
-    result instanceof UnitType
-  ) else (
-    isUnitBlockExpr(be) and
-    path.isEmpty() and
-    result instanceof UnitType
-  )
+private Type inferAsyncUnitBlockExprType(AsyncBlockExpr be, TypePath path) {
+  isUnitBlockExpr(be) and
+  path = TypePath::singleton(getDynFutureOutputTypeParameter()) and
+  result instanceof UnitType
 }
 
 pragma[nomagic]
-private predicate exprHasUnitType(Expr e) {
+private predicate exprHasUnitType(AstNode e) {
   e = any(IfExpr ie | not ie.hasElse())
   or
   e instanceof WhileExpr
   or
   e instanceof ForExpr
+  or
+  e instanceof AssignmentOperation
+  or
+  e = any(BlockExpr be | isUnitBlockExpr(be) and not be.isAsync())
+  or
+  exists(CallExprImpl::DynamicCallExpr dce |
+    e = dce.getArgList() and
+    dce.getNumberOfSyntacticArguments() = 0
+  )
 }
 
 final private class AwaitTarget extends Expr {
@@ -2022,17 +2011,10 @@ private Type inferAwaitExprType(AstNode n, TypePath path) {
   )
 }
 
-/**
- * Gets the root type of the array expression `ae`.
- */
-pragma[nomagic]
-private Type inferArrayExprType(ArrayExpr ae) { exists(ae) and result instanceof ArrayType }
-
-/**
- * Gets the root type of the range expression `re`.
- */
 pragma[nomagic]
-private Type inferRangeExprType(RangeExpr re) { result = TDataType(getRangeType(re)) }
+private Type inferRangeFullExprType(RangeFullExpr re) {
+  exists(re) and result = TDataType(any(RangeFullStruct t))
+}
 
 /**
  * A matching configuration for resolving types of deconstruction patterns like
@@ -2144,15 +2126,6 @@ private Type inferForLoopExprType(AstNode n, TypePath path) {
   )
 }
 
-pragma[nomagic]
-private TupleType inferArgList(ArgList args, TypePath path) {
-  exists(CallExprImpl::DynamicCallExpr dce |
-    args = dce.getArgList() and
-    result.getArity() = dce.getNumberOfSyntacticArguments() and
-    path.isEmpty()
-  )
-}
-
 /** Holds if `n` is implicitly dereferenced and/or borrowed. */
 cached
 predicate implicitDerefChainBorrow(Expr e, DerefChain derefChain, boolean borrow) {
@@ -2943,72 +2916,12 @@ private module Input3 implements InputSig3 {
     exists(c)
   }
 
-  predicate stepCertainLanguageSpecific(AstNode n1, TypePath prefix1, AstNode n2, TypePath prefix2) {
-    n1 =
-      any(IdentPat ip |
-        n2 = ip.getName() and
-        prefix1.isEmpty() and
-        if ip.isRef()
-        then
-          exists(boolean isMutable | if ip.isMut() then isMutable = true else isMutable = false |
-            prefix2 = TypePath::singleton(getRefTypeParameter(isMutable))
-          )
-        else prefix2.isEmpty()
-      )
-    or
-    // Rust closure types like `Fn<(A, B) -> C>` are syntactic sugar for `Fn<Args = (A, B), Output = C>`,
-    // so in calls to a closure, we consider the entire argument list as a single tuple argument.
-    exists(CallExprImpl::DynamicCallExpr dce, TupleType tt, int i |
-      n1 = dce.getSyntacticPositionalArgument(i) and
-      n2 = dce.getArgList() and
-      tt.getArity() = dce.getNumberOfSyntacticArguments() and
-      prefix1.isEmpty() and
-      prefix2 = TypePath::singleton(tt.getPositionalTypeParameter(i))
-    )
-  }
-
   pragma[nomagic]
   private Type inferClosureArgsType(ClosureExpr ce, TypePath path) {
     path = TypePath::singleton(TDynTraitTypeParameter(_, any(FnTrait t).getTypeParam())) and
     result.(TupleType).getArity() = ce.getNumberOfParams()
   }
 
-  pragma[nomagic]
-  Type inferTypeCertainLanguageSpecific(AstNode n, TypePath path) {
-    result = inferLiteralType(n, path, true)
-    or
-    result = inferRefPatType(n) and
-    path.isEmpty()
-    or
-    result = inferRefExprType(n) and
-    path.isEmpty()
-    or
-    result = inferStructExprType(n, path)
-    or
-    result = inferStructPatType(n, path)
-    or
-    result = inferAssignmentOperationType(n, path)
-    or
-    result = inferRangeExprType(n) and
-    path.isEmpty()
-    or
-    result = inferTupleRootType(n) and
-    path.isEmpty()
-    or
-    result = inferBlockExprType(n, path)
-    or
-    result = inferArrayExprType(n) and
-    path.isEmpty()
-    or
-    result = inferArgList(n, path)
-    or
-    exprHasUnitType(n) and
-    path.isEmpty() and
-    result instanceof UnitType
-    or
-    result = inferClosureArgsType(n, path)
-  }
-
   predicate stepLanguageSpecific(AstNode n1, TypePath prefix1, AstNode n2, TypePath prefix2) {
     // When `n2` is `*n1` propagate type information from a raw pointer type
     // parameter at `n1` (all other deref expressions are handled as calls)
@@ -3046,6 +2959,26 @@ private module Input3 implements InputSig3 {
       n2.(ArrayRepeatExpr).getRepeatOperand() = n1 and
       prefix2 = TypePath::singleton(getArrayTypeParameter())
       or
+      // Rust closure types like `Fn<(A, B) -> C>` are syntactic sugar for `Fn<Args = (A, B), Output = C>`,
+      // so in calls to a closure, we consider the entire argument list as a single tuple argument.
+      exists(CallExprImpl::DynamicCallExpr dce, TupleType tt, int i |
+        n1 = dce.getSyntacticPositionalArgument(i) and
+        n2 = dce.getArgList() and
+        tt.getArity() = dce.getNumberOfSyntacticArguments() and
+        prefix2 = TypePath::singleton(tt.getPositionalTypeParameter(i))
+      )
+      or
+      n1 =
+        any(IdentPat ip |
+          n2 = ip.getName() and
+          if ip.isRef()
+          then
+            exists(boolean isMutable | if ip.isMut() then isMutable = true else isMutable = false |
+              prefix2 = TypePath::singleton(getRefTypeParameter(isMutable))
+            )
+          else prefix2.isEmpty()
+        )
+      or
       prefix2.isEmpty() and
       (
         n2 = n1.(OrPat).getAPat()
@@ -3124,6 +3057,32 @@ private module Input3 implements InputSig3 {
     or
     result = inferUnknownType(n, path)
   }
+
+  pragma[nomagic]
+  Type inferTypeCertainLanguageSpecific(AstNode n, TypePath path) {
+    result = inferLiteralType(n, path, true)
+    or
+    result = inferRefPatType(n) and
+    path.isEmpty()
+    or
+    result = inferStructExprType(n, path)
+    or
+    result = inferStructPatType(n, path)
+    or
+    result = inferRangeFullExprType(n) and
+    path.isEmpty()
+    or
+    result = inferTupleRootType(n) and
+    path.isEmpty()
+    or
+    result = inferAsyncUnitBlockExprType(n, path)
+    or
+    exprHasUnitType(n) and
+    path.isEmpty() and
+    result instanceof UnitType
+    or
+    result = inferClosureArgsType(n, path)
+  }
 }
 
 private module M3 = Make3<Input3>;