dbg2

Author: hvitved

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

@@ -210,6 +210,19 @@ private TypeMention getTypeAnnotation(AstNode n) {
   )
 }
 
+private predicate hasKnownType(AstNode n) {
+  none()
+  // exists(TypeMention tm |
+  //   tm = getTypeAnnotation(n) and
+  //   not tm = any(InferTypeRepr itr).getParentNode*()
+  // )
+  // or
+  // n instanceof SelfParam
+  // or
+  // n.getLocation().getStartLine() in [1495 .. 1499] and
+  // n.getFile().getBaseName() = "ordered_float.rs"
+}
+
 /** Gets the type of `n`, which has an explicit type annotation. */
 pragma[nomagic]
 private Type inferAnnotatedType(AstNode n, TypePath path) {
@@ -302,7 +315,8 @@ 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)
+    path = prefix1.append(suffix) and
+    not hasKnownType(n)
   |
     typeEquality(n, prefix1, n2, prefix2)
     or
@@ -482,7 +496,8 @@ pragma[nomagic]
 private Type inferStructExprType(AstNode n, TypePath path) {
   exists(StructExprMatchingInput::Access a, StructExprMatchingInput::AccessPosition apos |
     n = a.getNodeAt(apos) and
-    result = StructExprMatching::inferAccessType(a, apos, path)
+    result = StructExprMatching::inferAccessType(a, apos, path) and
+    not hasKnownType(n)
   )
 }
 
@@ -526,12 +541,25 @@ private module CallExprBaseMatchingInput implements MatchingInputSig {
     }
   }
 
+  private Locatable getRelevantLocatable() {
+    exists(string filepath, int startline, int startcolumn, int endline, int endcolumn |
+      result.getLocation().hasLocationInfo(filepath, startline, startcolumn, endline, endcolumn) and
+      filepath.matches("%/common/hashtable/src/hashtable.rs") and
+      startline = [128, 156]
+    )
+  }
+
   abstract class Declaration extends AstNode {
     abstract TypeParameter getTypeParameter(TypeParameterPosition ppos);
 
     pragma[nomagic]
     abstract Type getParameterType(DeclarationPosition dpos, TypePath path);
 
+    private Type dbggetDeclaredType(DeclarationPosition dpos, TypePath path) {
+      this = getRelevantLocatable() and
+      result = this.getDeclaredType(dpos, path)
+    }
+
     abstract Type getReturnType(TypePath path);
 
     Type getDeclaredType(DeclarationPosition dpos, TypePath path) {
@@ -749,6 +777,13 @@ private module CallExprBaseMatchingInput implements MatchingInputSig {
       or
       result = CallExprImpl::getResolvedFunction(this)
     }
+
+    private Declaration dbggetTarget() {
+      this = getRelevantLocatable() and
+      result = resolveMethodCallTarget(this) // mutual recursion; resolving method calls requires resolving types and vice versa
+      // or
+      // result = CallExprImpl::getResolvedFunction(this)
+    }
   }
 
   predicate accessDeclarationPositionMatch(AccessPosition apos, DeclarationPosition dpos) {
@@ -826,7 +861,8 @@ private Type inferCallExprBaseType(AstNode n, TypePath path) {
     TypePath path0
   |
     n = a.getNodeAt(apos) and
-    result = CallExprBaseMatching::inferAccessType(a, apos, path0)
+    result = CallExprBaseMatching::inferAccessType(a, apos, path0) and
+    not hasKnownType(n)
   |
     if
       apos.isBorrowed(true)
@@ -987,7 +1023,8 @@ private Type inferFieldExprType(AstNode n, TypePath path) {
     FieldExprMatchingInput::Access a, FieldExprMatchingInput::AccessPosition apos, TypePath path0
   |
     n = a.getNodeAt(apos) and
-    result = FieldExprMatching::inferAccessType(a, apos, path0)
+    result = FieldExprMatching::inferAccessType(a, apos, path0) and
+    not hasKnownType(n)
   |
     if apos.isSelf()
     then
@@ -1592,8 +1629,8 @@ private module Debug {
   private Locatable getRelevantLocatable() {
     exists(string filepath, int startline, int startcolumn, int endline, int endcolumn |
       result.getLocation().hasLocationInfo(filepath, startline, startcolumn, endline, endcolumn) and
-      filepath.matches("%/sqlx.rs") and
-      startline = [56 .. 60]
+      filepath.matches("%/expression/src/utils/arithmetics_type.rs") and
+      startline = 1049
     )
   }
 
@@ -1607,19 +1644,52 @@ private module Debug {
     result = resolveMethodCallTarget(mce)
   }
 
+  predicate debugInferImplicitSelfType(SelfParam self, TypePath path, Type t) {
+    self = getRelevantLocatable() and
+    t = inferImplicitSelfType(self, path)
+  }
+
+  predicate debugInferCallExprBaseType(AstNode n, TypePath path, Type t) {
+    n = getRelevantLocatable() and
+    t = inferCallExprBaseType(n, path)
+  }
+
   predicate debugTypeMention(TypeMention tm, TypePath path, Type type) {
     tm = getRelevantLocatable() and
     tm.resolveTypeAt(path) = type
   }
 
   pragma[nomagic]
-  private int countTypes(AstNode n, TypePath path, Type t) {
+  private int countTypesAtPath(AstNode n, TypePath path, Type t) {
     t = inferType(n, path) and
     result = strictcount(Type t0 | t0 = inferType(n, path))
   }
 
   predicate maxTypes(AstNode n, TypePath path, Type t, int c) {
-    c = countTypes(n, path, t) and
-    c = max(countTypes(_, _, _))
+    c = countTypesAtPath(n, path, t) and
+    c = max(countTypesAtPath(_, _, _))
+  }
+
+  pragma[nomagic]
+  private predicate typePathLength(AstNode n, TypePath path, Type t, int len) {
+    t = inferType(n, path) and
+    len = path.length() and
+    not n.getFile().getBaseName() = "ordered_float.rs"
+  }
+
+  predicate maxTypePath(AstNode n, TypePath path, Type t, int len) {
+    typePathLength(n, path, t, len) and
+    len = max(int i | typePathLength(_, _, _, i))
+  }
+
+  pragma[nomagic]
+  private int countTypePaths(AstNode n, TypePath path, Type t) {
+    t = inferType(n, path) and
+    result = strictcount(TypePath path0, Type t0 | t0 = inferType(n, path0))
+  }
+
+  predicate maxTypePaths(AstNode n, TypePath path, Type t, int c) {
+    c = countTypePaths(n, path, t) and
+    c = max(countTypePaths(_, _, _))
   }
 }

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

@@ -1440,6 +1440,16 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
         typeConstraintBaseTypeMatch(a, target, path, t, tp)
       }
 
+      private predicate debugtypeMatch(
+        Access a, Declaration target, TypePath path, Type t, TypeParameter tp
+      ) {
+        typeMatch(a, target, path, t, tp) and
+        a.getLocation()
+            .hasLocationInfo(any(string filePath |
+                filePath.matches("%/common/hashtable/src/hashtable.rs")
+              ), 156, _, _, _)
+      }
+
       /**
        * Gets the inferred type of `a` at `path` for position `apos`.
        *
@@ -1496,6 +1506,28 @@ module Make1<LocationSig Location, InputSig1<Location> Input1> {
           )
         )
       }
+
+      private Type debuginferAccessType(
+        Access a, DeclarationPosition dpos, Declaration target, AccessPosition apos, TypePath path
+      ) {
+        // result = inferAccessType(a, apos, path) and
+        accessDeclarationPositionMatch(apos, dpos) and
+        // A suffix of `path` leads to a type parameter in the target
+        // exists(Declaration target, TypePath prefix, TypeParameter tp, TypePath suffix |
+        //   tp = target.getDeclaredType(dpos, prefix) and
+        //   path = prefix.append(suffix) and
+        //   typeMatch(a, target, suffix, result, tp)
+        // )
+        // or
+        // `path` corresponds directly to a concrete type in the declaration
+        result = target.getDeclaredType(dpos, path) and
+        target = a.getTarget() and
+        not result instanceof TypeParameter and
+        a.getLocation()
+            .hasLocationInfo(any(string filePath |
+                filePath.matches("%/common/hashtable/src/hashtable.rs")
+              ), 156, _, _, _)
+      }
     }
 
     /** Provides consistency checks. */