wip

Author: hvitved

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

@@ -290,9 +290,22 @@ private module Input3 implements InputSig3 {
 
   class AstNode = Rust::AstNode;
 
-  predicate getTypeAnnotation = getTypeAnnotation_/1;
+  TypeMention getTypeAnnotation(AstNode n) {
+    exists(LetStmt let |
+      n = let.getPat() and
+      result = let.getTypeRepr()
+    )
+    or
+    result = n.(SelfParam).getTypeRepr()
+    or
+    exists(Param p |
+      n = p.getPat() and
+      result = p.getTypeRepr()
+    )
+    or
+    result = n.(ShorthandSelfParameterMention)
+  }
 
-  /** A variable, for example a local variable or a field. */
   class Variable extends Rust::Variable {
     AstNode getDefiningNode() {
       result = this.getPat().getName() or
@@ -511,28 +524,6 @@ private Type getCallExprTypeArgument(CallExpr ce, TypeArgumentPosition apos, Typ
   )
 }
 
-/** Gets the type annotation that applies to `n`, if any. */
-private TypeMention getTypeAnnotation_(AstNode n) {
-  exists(LetStmt let |
-    n = let.getPat() and
-    result = let.getTypeRepr()
-  )
-  or
-  result = n.(SelfParam).getTypeRepr()
-  or
-  exists(Param p |
-    n = p.getPat() and
-    result = p.getTypeRepr()
-  )
-  or
-  result = n.(ShorthandSelfParameterMention)
-}
-
-// /** Gets the type of `n`, which has an explicit type annotation. */
-// pragma[nomagic]
-// private Type inferAnnotatedType(AstNode n, TypePath path) {
-//   result = getTypeAnnotation(n).getTypeAt(path)
-// }
 pragma[nomagic]
 private Type inferFunctionBodyType(AstNode n, TypePath path) {
   exists(Function f |
@@ -656,30 +647,6 @@ module CertainTypeInference_ {
   }
 
   predicate certainTypeEquality_(AstNode n1, TypePath prefix1, AstNode n2, TypePath prefix2) {
-    // prefix1.isEmpty() and
-    // prefix2.isEmpty() and
-    // (
-    //   exists(Variable v | n1 = v.getAnAccess() |
-    //     n2 = v.getPat().getName() or n2 = v.getParameter().(SelfParam)
-    //   )
-    //   or
-    //   // // A `let` statement with a type annotation is a coercion site and hence
-    //   // // is not a certain type equality.
-    //   // exists(LetStmt let |
-    //   //   not let.hasTypeRepr() and
-    //   //   identLetStmt(let, n1, n2)
-    //   // )
-    //   // or
-    //   // exists(LetExpr let |
-    //   //   // Similarly as for let statements, we need to rule out binding modes
-    //   //   // changing the type.
-    //   //   let.getPat().(IdentPat) = n1 and
-    //   //   let.getScrutinee() = n2
-    //   // )
-    //   // or
-    //   n1 = n2.(ParenExpr).getExpr()
-    // )
-    // or
     n1 =
       any(IdentPat ip |
         n2 = ip.getName() and
@@ -708,31 +675,15 @@ module CertainTypeInference_ {
     )
   }
 
-  // pragma[nomagic]
-  // private Type inferCertainTypeEquality(AstNode n, TypePath path) {
-  //   exists(TypePath prefix1, AstNode n2, TypePath prefix2, TypePath suffix |
-  //     result = inferCertainType(n2, prefix2.appendInverse(suffix)) and
-  //     path = prefix1.append(suffix)
-  //   |
-  //     certainTypeEquality(n, prefix1, n2, prefix2)
-  //     or
-  //     certainTypeEquality(n2, prefix2, n, prefix1)
-  //   )
-  // }
   /**
    * Holds if `n` has complete and certain type information and if `n` has the
    * resulting type at `path`.
    */
   Type inferCertainType_(AstNode n, TypePath path) {
-    // result = inferAnnotatedType(n, path) and
-    // Stages::TypeInferenceStage::ref()
-    // or
     result = inferFunctionBodyType(n, path)
     or
     result = inferCertainCallExprType(n, path)
     or
-    // result = inferCertainTypeEquality(n, path)
-    // or
     result = inferLiteralType(n, path, true)
     or
     result = inferRefPatType(n) and
@@ -771,48 +722,7 @@ module CertainTypeInference_ {
     n instanceof ClosureExpr and
     path.isEmpty() and
     result = closureRootType()
-    // or
-    // infersCertainTypeAt(n, path, result.getATypeParameter())
-  }
-  // /**
-  //  * Holds if `n` has complete and certain type information at the type path
-  //  * `prefix.tp`. This entails that the type at `prefix` must be the type
-  //  * that declares `tp`.
-  //  */
-  // pragma[nomagic]
-  // private predicate infersCertainTypeAt(AstNode n, TypePath prefix, TypeParameter tp) {
-  //   exists(TypePath path |
-  //     exists(inferCertainType(n, path)) and
-  //     path.isSnoc(prefix, tp)
-  //   )
-  // }
-  // /**
-  //  * Holds if `n` has complete and certain type information at `path`.
-  //  */
-  // pragma[nomagic]
-  // predicate hasInferredCertainType(AstNode n, TypePath path) { exists(inferCertainType(n, path)) }
-  // /**
-  //  * Holds if `n` having type `t` at `path` conflicts with certain type information
-  //  * at `prefix`.
-  //  */
-  // bindingset[n, prefix, path, t]
-  // pragma[inline_late]
-  // predicate certainTypeConflict(AstNode n, TypePath prefix, TypePath path, Type t) {
-  //   inferCertainType(n, path) != t
-  //   or
-  //   // If we infer that `n` has _some_ type at `T1.T2....Tn`, and we also
-  //   // know that `n` certainly has type `certainType` at `T1.T2...Ti`, `0 <= i < n`,
-  //   // then it must be the case that `T(i+1)` is a type parameter of `certainType`,
-  //   // otherwise there is a conflict.
-  //   //
-  //   // Below, `prefix` is `T1.T2...Ti` and `tp` is `T(i+1)`.
-  //   exists(TypePath suffix, TypeParameter tp, Type certainType |
-  //     path = prefix.appendInverse(suffix) and
-  //     tp = suffix.getHead() and
-  //     inferCertainType(n, prefix) = certainType and
-  //     not certainType.getATypeParameter() = tp
-  //   )
-  // }
+  }
 }
 
 private Type inferLogicalOperationType(AstNode n, TypePath path) {
@@ -864,27 +774,15 @@ private predicate bodyReturns(Expr body, Expr e) {
  * through the type equality.
  */
 private predicate typeEquality_(AstNode n1, TypePath prefix1, AstNode n2, TypePath prefix2) {
-  // CertainTypeInference::certainTypeEquality(n1, prefix1, n2, prefix2)
-  // or
   prefix1.isEmpty() and
   prefix2.isEmpty() and
   (
-    // exists(LetStmt let |
-    //   let.getPat() = n1 and
-    //   let.getInitializer() = n2
-    // )
-    // or
     n2 =
       any(MatchExpr me |
         n1 = me.getAnArm().getExpr() and
         me.getNumberOfArms() = 1
       )
     or
-    // exists(LetExpr let |
-    //   n1 = let.getScrutinee() and
-    //   n2 = let.getPat()
-    // )
-    // or
     exists(MatchExpr me |
       n1 = me.getScrutinee() and
       n2 = me.getAnArm().getPat()
@@ -982,9 +880,6 @@ private predicate typeEquality_(AstNode n1, TypePath prefix1, AstNode n2, TypePa
  * [1]: https://doc.rust-lang.org/reference/type-coercions.html#r-coerce.least-upper-bound
  */
 private predicate lubCoercion_(AstNode parent, AstNode child, TypePath prefix) {
-  // child = parent.(IfExpr).getABranch() and
-  // prefix.isEmpty()
-  // or
   parent =
     any(MatchExpr me |
       child = me.getAnArm().getExpr() and
@@ -1032,18 +927,6 @@ private Type inferUnknownTypeFromAnnotation(AstNode n, TypePath path) {
  * `n2`.
  */
 private predicate typeEqualityAsymmetric_(AstNode n1, TypePath prefix1, AstNode n2, TypePath prefix2) {
-  // lubCoercion(n2, n1, prefix2) and
-  // prefix1.isEmpty()
-  // or
-  // exists(AstNode mid, TypePath prefixMid, TypePath suffix |
-  //   typeEquality(n1, prefixMid, mid, prefix2) or
-  //   typeEquality(mid, prefix2, n1, prefixMid)
-  // |
-  //   lubCoercion(mid, n2, suffix) and
-  //   not lubCoercion(mid, n1, _) and
-  //   prefix1 = prefixMid.append(suffix)
-  // )
-  // or
   // When `n2` is `*n1` propagate type information from a raw pointer type
   // parameter at `n1`. The other direction is handled in
   // `inferDereferencedExprPtrType`.
@@ -1052,19 +935,6 @@ private predicate typeEqualityAsymmetric_(AstNode n1, TypePath prefix1, AstNode
   prefix2.isEmpty()
 }
 
-// pragma[nomagic]
-// private Type inferTypeEquality(AstNode n, TypePath path) {
-//   exists(TypePath prefix1, AstNode n2, TypePath prefix2, TypePath suffix |
-//     result = inferType(n2, prefix2.appendInverse(suffix)) and
-//     path = prefix1.append(suffix)
-//   |
-//     typeEquality(n, prefix1, n2, prefix2)
-//     or
-//     typeEquality(n2, prefix2, n, prefix1)
-//     or
-//     typeEqualityAsymmetric(n2, prefix2, n, prefix1)
-//   )
-// }
 pragma[nomagic]
 private TupleType inferTupleRootType(AstNode n) {
   // `typeEquality` handles the non-root cases
@@ -3362,6 +3232,19 @@ private Type getFieldExprLookupType(FieldExpr fe, string name, DerefChain derefC
   )
 }
 
+/**
+ * Gets the struct field that the field expression `fe` resolves to, if any.
+ */
+cached
+StructField resolveStructFieldExpr(FieldExpr fe, DerefChain derefChain) {
+  exists(string name, DataType ty |
+    ty = getFieldExprLookupType(fe, pragma[only_bind_into](name), derefChain)
+  |
+    result = ty.(StructType).getTypeItem().getStructField(pragma[only_bind_into](name)) or
+    result = ty.(UnionType).getTypeItem().getStructField(pragma[only_bind_into](name))
+  )
+}
+
 pragma[nomagic]
 private Type getTupleFieldExprLookupType(FieldExpr fe, int pos, DerefChain derefChain) {
   exists(string name |
@@ -3370,6 +3253,20 @@ private Type getTupleFieldExprLookupType(FieldExpr fe, int pos, DerefChain deref
   )
 }
 
+/**
+ * Gets the tuple field that the field expression `fe` resolves to, if any.
+ */
+cached
+TupleField resolveTupleFieldExpr(FieldExpr fe, DerefChain derefChain) {
+  exists(int i |
+    result =
+      getTupleFieldExprLookupType(fe, pragma[only_bind_into](i), derefChain)
+          .(StructType)
+          .getTypeItem()
+          .getTupleField(pragma[only_bind_into](i))
+  )
+}
+
 /**
  * A matching configuration for resolving types of field expressions like `x.field`.
  */
@@ -3897,50 +3794,9 @@ Addressable resolveCallTarget(InvocationExpr call, boolean dispatch) {
   )
 }
 
-/**
- * Gets the struct field that the field expression `fe` resolves to, if any.
- */
-cached
-StructField resolveStructFieldExpr(FieldExpr fe, DerefChain derefChain) {
-  exists(string name, DataType ty |
-    ty = getFieldExprLookupType(fe, pragma[only_bind_into](name), derefChain)
-  |
-    result = ty.(StructType).getTypeItem().getStructField(pragma[only_bind_into](name)) or
-    result = ty.(UnionType).getTypeItem().getStructField(pragma[only_bind_into](name))
-  )
-}
-
-/**
- * Gets the tuple field that the field expression `fe` resolves to, if any.
- */
-cached
-TupleField resolveTupleFieldExpr(FieldExpr fe, DerefChain derefChain) {
-  exists(int i |
-    result =
-      getTupleFieldExprLookupType(fe, pragma[only_bind_into](i), derefChain)
-          .(StructType)
-          .getTypeItem()
-          .getTupleField(pragma[only_bind_into](i))
-  )
-}
-
 private Type inferType_(AstNode n, TypePath path) {
-  // // Stages::TypeInferenceStage::ref() and
-  // // result = CertainTypeInference::inferCertainType(n, path)
-  // // or
-  // // Don't propagate type information into a node which conflicts with certain
-  // // type information.
-  // forall(TypePath prefix |
-  //   CertainTypeInference::hasInferredCertainType(n, prefix) and
-  //   prefix.isPrefixOf(path)
-  // |
-  //   not CertainTypeInference::certainTypeConflict(n, prefix, path, result)
-  // ) and
-  // (
   result = inferAssignmentOperationType(n, path)
   or
-  // result = inferTypeEquality(n, path)
-  // or
   result = inferFunctionCallType(n, path)
   or
   result = inferConstructionType(n, path)
@@ -3966,7 +3822,6 @@ private Type inferType_(AstNode n, TypePath path) {
   result = inferDeconstructionPatType(n, path)
   or
   result = inferUnknownTypeFromAnnotation(n, path)
-  // )
 }
 
 /** Provides predicates for debugging the type inference implementation. */

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

@@ -2208,7 +2208,7 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
 
       /**
        * Holds if the type tree of `n1` at `path1` should be equal to the type tree
-       * of `n2` at `prefix2`, but type information should only propagate from `n1` to
+       * of `n2` at `path2`, but type information should only propagate from `n1` to
        * `n2`.
        */
       predicate typeEqualityAsymmetricInput(AstNode n1, TypePath path1, AstNode n2, TypePath path2);