wip

Author: hvitved

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

@@ -257,59 +257,75 @@ private Type inferAnnotatedType(AstNode n, TypePath path) {
 
 /** Module for inferring certain type information. */
 private module CertainTypeInference {
-  /**
-   * Holds if `ce` is a call where we can infer the type with certainty and if
-   * `f` is the target of the call and `p` the path invoked by the call.
-   *
-   * Necessary conditions for this are:
-   * - We are certain of the call target (i.e., the call target can not depend on type information).
-   * - The declared type of the function does not contain any generics that we
-   *   need to infer.
-   * - The call does not contain any arguments, as arguments in calls are coercion sites.
-   *
-   * The current requirements are made to allow for call to `new` functions such
-   * as `Vec<Foo>::new()` but not much more.
-   */
-  predicate certainCallExprTarget(CallExpr ce, Function f, Path p) {
+  // /**
+  //  * Holds if `ce` is a call where we can infer the type with certainty and if
+  //  * `f` is the target of the call and `p` the path invoked by the call.
+  //  *
+  //  * Necessary conditions for this are:
+  //  * - We are certain of the call target (i.e., the call target can not depend on type information).
+  //  * - The declared type of the function does not contain any generics that we
+  //  *   need to infer.
+  //  * - The call does not contain any arguments, as arguments in calls are coercion sites.
+  //  *
+  //  * The current requirements are made to allow for call to `new` functions such
+  //  * as `Vec<Foo>::new()` but not much more.
+  //  */
+  // predicate certainCallExprTarget(CallExpr ce, Function f, Path p) {
+  //   p = CallExprImpl::getFunctionPath(ce) and
+  //   f = resolvePath(p) and
+  //   // The function is not in a trait
+  //   not any(TraitItemNode t).getAnAssocItem() = f and
+  //   // The function is not in a trait implementation
+  //   not any(ImplItemNode impl | impl.(Impl).hasTrait()).getAnAssocItem() = f and
+  //   // The function does not have parameters.
+  //   not f.getParamList().hasSelfParam() and
+  //   f.getParamList().getNumberOfParams() = 0 and
+  //   // The function is not async.
+  //   not f.isAsync() and
+  //   // For now, exclude functions in macro expansions.
+  //   not ce.isInMacroExpansion() and
+  //   // The function has no type parameters.
+  //   not f.hasGenericParamList() and
+  //   // The function does not have `impl` types among its parameters (these are type parameters).
+  //   not any(ImplTraitTypeRepr itt | not itt.isInReturnPos()).getFunction() = f and
+  //   (
+  //     not exists(ImplItemNode impl | impl.getAnAssocItem() = f)
+  //     or
+  //     // If the function is in an impl then the impl block has no type
+  //     // parameters or all the type parameters are given explicitly.
+  //     exists(ImplItemNode impl | impl.getAnAssocItem() = f |
+  //       not impl.(Impl).hasGenericParamList() or
+  //       impl.(Impl).getGenericParamList().getNumberOfGenericParams() =
+  //         p.getQualifier().getSegment().getGenericArgList().getNumberOfGenericArgs()
+  //     )
+  //   )
+  // }
+  pragma[nomagic]
+  private predicate callResolvesTo(CallExpr ce, Path p, Function f) {
     p = CallExprImpl::getFunctionPath(ce) and
-    f = resolvePath(p) and
-    // The function is not in a trait
-    not any(TraitItemNode t).getAnAssocItem() = f and
-    // The function is not in a trait implementation
-    not any(ImplItemNode impl | impl.(Impl).hasTrait()).getAnAssocItem() = f and
-    // The function does not have parameters.
-    not f.getParamList().hasSelfParam() and
-    f.getParamList().getNumberOfParams() = 0 and
-    // The function is not async.
-    not f.isAsync() and
-    // For now, exclude functions in macro expansions.
-    not ce.isInMacroExpansion() and
-    // The function has no type parameters.
-    not f.hasGenericParamList() and
-    // The function does not have `impl` types among its parameters (these are type parameters).
-    not any(ImplTraitTypeRepr itt | not itt.isInReturnPos()).getFunction() = f and
-    (
-      not exists(ImplItemNode impl | impl.getAnAssocItem() = f)
-      or
-      // If the function is in an impl then the impl block has no type
-      // parameters or all the type parameters are given explicitly.
-      exists(ImplItemNode impl | impl.getAnAssocItem() = f |
-        not impl.(Impl).hasGenericParamList() or
-        impl.(Impl).getGenericParamList().getNumberOfGenericParams() =
-          p.getQualifier().getSegment().getGenericArgList().getNumberOfGenericArgs()
-      )
-    )
+    f = resolvePath(p)
+  }
+
+  pragma[nomagic]
+  private Type getCallExprType(CallExpr ce, Path p, Function f, TypePath tp) {
+    callResolvesTo(ce, p, f) and
+    result = f.(CallExprBaseMatchingInput::FunctionDecl).getReturnType(tp)
+  }
+
+  pragma[nomagic]
+  private Type getCertainCallExprType(CallExpr ce, Path p, TypePath tp) {
+    forex(Function f | callResolvesTo(ce, p, f) | result = getCallExprType(ce, p, f, tp))
   }
 
   private ImplItemNode getFunctionImpl(FunctionItemNode f) { result.getAnAssocItem() = f }
 
   Type inferCertainCallExprType(CallExpr ce, TypePath path) {
     exists(Function f, Type ty, TypePath prefix, Path p |
-      certainCallExprTarget(ce, f, p) and
-      ty = f.getRetType().getTypeRepr().(TypeMention).resolveTypeAt(prefix)
+      ty = getCertainCallExprType(ce, p, prefix)
     |
-      if ty.(TypeParamTypeParameter).getTypeParam() = getFunctionImpl(f).getTypeParam(_)
+      if ty instanceof TypeParameter
       then
+        ty.(TypeParamTypeParameter).getTypeParam() = getFunctionImpl(f).getTypeParam(_) and
         exists(TypePath pathToTp, TypePath suffix |
           // For type parameters of the `impl` block we must resolve their
           // instantiation from the path. For instance, for `impl<A> for Foo<A>`
@@ -878,7 +894,7 @@ private module CallExprBaseMatchingInput implements MatchingInputSig {
     }
   }
 
-  private class FunctionDecl extends Declaration, Function {
+  additional class FunctionDecl extends Declaration, Function {
     override TypeParameter getTypeParameter(TypeParameterPosition ppos) {
       typeParamMatchPosition(this.getGenericParamList().getATypeParam(), result, ppos)
       or
@@ -980,8 +996,7 @@ private module CallExprBaseMatchingInput implements MatchingInputSig {
   }
 
   final class Access extends Call {
-    Access() { not CertainTypeInference::certainCallExprTarget(this, _, _) }
-
+    // Access() { not CertainTypeInference::certainCallExprTarget(this, _, _) }
     pragma[nomagic]
     Type getTypeArgument(TypeArgumentPosition apos, TypePath path) {
       exists(TypeMention arg | result = arg.resolveTypeAt(path) |