param

Author: hvitved

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

@@ -453,22 +453,19 @@ private module Input3 implements InputSig3 {
     override TypeMention getType() { result = super.getTypeRepr() }
   }
 
-  final class Callable = CallableImpl;
+  final class Parameterizable = ParameterizableImpl;
 
-  /** A callable, including enum/struct constructors. */
-  abstract private class CallableImpl extends AstNode {
+  abstract private class ParameterizableImpl extends AstNode {
     abstract TypeParameter getTypeParameter(TypeParameterPosition ppos);
 
     abstract TypeMention getAdditionalTypeParameterConstraint(TypeParameter tp);
 
     abstract Parameter getParameter(int i);
 
-    abstract TypeMention getReturnType();
-
-    abstract AstNode getBody();
+    abstract TypeMention getType();
   }
 
-  private class CallableCallable extends CallableImpl instanceof Rust::Callable {
+  class Callable extends ParameterizableImpl instanceof Rust::Callable {
     override TypeParameter getTypeParameter(TypeParameterPosition ppos) {
       result = this.(FunctionDeclaration).getTypeParameter(ppos)
     }
@@ -487,24 +484,22 @@ private module Input3 implements InputSig3 {
       )
     }
 
-    override TypeMention getReturnType() { result = getReturnTypeMention(this) }
+    override TypeMention getType() { result = getReturnTypeMention(this) }
 
-    override AstNode getBody() { result = Rust::Callable.super.getBody() }
+    AstNode getBody() { result = Rust::Callable.super.getBody() }
   }
 
   additional final class Constructor = ConstructorImpl;
 
-  abstract private class ConstructorImpl extends CallableImpl {
+  abstract private class ConstructorImpl extends ParameterizableImpl {
     override TypeMention getAdditionalTypeParameterConstraint(TypeParameter tp) { none() }
 
     override TypeParameter getTypeParameter(TypeParameterPosition ppos) {
       result = ppos.asTypeParameter() and
       ppos.asTypeParam() = this.getTypeItem().getGenericParamList().getATypeParam()
     }
 
-    override TypeMention getReturnType() { none() }
-
-    override AstNode getBody() { none() }
+    override TypeMention getType() { result = this.getTypeItem() }
 
     abstract TypeItem getTypeItem();
   }
@@ -525,33 +520,25 @@ private module Input3 implements InputSig3 {
     }
   }
 
-  Type getCallableReturnType(Callable c, TypePath path) {
-    c =
-      any(Constructor constructor |
-        result = TDataType(constructor.getTypeItem()) and
-        path.isEmpty()
-        or
-        result =
-          TTypeParamTypeParameter(constructor.getTypeItem().getGenericParamList().getATypeParam()) and
-        path = TypePath::singleton(result)
-      )
+  Type getParameterizableType(Parameterizable p, TypePath path) {
+    result = p.(Constructor).getType().getTypeAt(path)
     or
-    if c.(Function).isAsync()
+    if p.(Function).isAsync() or p.(ClosureExpr).isAsync()
     then
       path.isEmpty() and
       result = getFutureTraitType()
       or
       exists(TypePath suffix |
-        result = getReturnTypeMention(c).getTypeAt(suffix) and
+        result = getReturnTypeMention(p).getTypeAt(suffix) and
         path = TypePath::cons(getDynFutureOutputTypeParameter(), suffix)
       )
-    else result = getReturnTypeMention(c).getTypeAt(path)
+    else result = getReturnTypeMention(p).getTypeAt(path)
   }
 
-  class CallResolutionContext = string;
+  class ResolutionContext = string;
 
   bindingset[derefChain, borrow]
-  private CallResolutionContext encodeDerefChainBorrow(DerefChain derefChain, BorrowKind borrow) {
+  private ResolutionContext encodeDerefChainBorrow(DerefChain derefChain, BorrowKind borrow) {
     result = derefChain + ";" + borrow
   }
 
@@ -574,18 +561,17 @@ private module Input3 implements InputSig3 {
     )
   }
 
-  final class Call = CallImpl;
+  final class Invocation = InvocationImpl;
 
-  /** A call expression, including enum/struct constructions. */
-  abstract private class CallImpl extends Expr {
+  abstract private class InvocationImpl extends Expr {
     abstract Type getTypeArgument(TypeArgumentPosition apos, TypePath path);
 
     abstract AstNode getArgument(int i);
 
-    abstract Callable getTarget(string derefChainBorrow);
+    abstract Parameterizable getTarget(string derefChainBorrow);
   }
 
-  private class AssocFunctionCall extends CallImpl instanceof AssocFunctionResolution::AssocFunctionCall
+  private class AssocFunctionCall extends InvocationImpl instanceof AssocFunctionResolution::AssocFunctionCall
   {
     pragma[nomagic]
     override Type getTypeArgument(TypeArgumentPosition apos, TypePath path) {
@@ -633,7 +619,7 @@ private module Input3 implements InputSig3 {
     }
   }
 
-  private class NonAssocFunctionCall extends CallImpl instanceof NonAssocCallExpr,
+  private class NonAssocFunctionCall extends InvocationImpl instanceof NonAssocCallExpr,
     CallExprImpl::CallExprCall
   {
     pragma[nomagic]
@@ -657,10 +643,10 @@ private module Input3 implements InputSig3 {
     }
   }
 
-  abstract private class Construction extends CallImpl {
+  abstract private class Construction extends InvocationImpl {
     abstract Constructor getTarget();
 
-    override Callable getTarget(string derefChainBorrow) {
+    override Parameterizable getTarget(string derefChainBorrow) {
       result = this.getTarget() and
       derefChainBorrow = noDerefChainBorrow()
     }
@@ -725,27 +711,30 @@ private module Input3 implements InputSig3 {
     override AstNode getArgument(int i) { none() }
   }
 
-  Callable getAdditionalCallTargetForContextualReturnTyping(Call call) {
-    result = CallExprImpl::getResolvedFunction(call)
+  Parameterizable getAdditionalTargetForContextualReturnTyping(Invocation invocation) {
+    result = CallExprImpl::getResolvedFunction(invocation)
   }
 
   pragma[nomagic]
-  private Type inferCallArgumentType0(Call call, int pos, TypePath path) {
+  private Type inferInvocationArgumentType0(Invocation invocation, int pos, TypePath path) {
     exists(FunctionPosition fpos |
       pos = fpos.asPosition() and
-      result = call.(AssocFunctionResolution::OperationAssocFunctionCall).getTypeAt(fpos, path)
+      result =
+        invocation.(AssocFunctionResolution::OperationAssocFunctionCall).getTypeAt(fpos, path)
     )
     or
-    not call instanceof Operation and
-    not call instanceof AssocFunctionCall and
-    result = inferType(call.getArgument(pos), path)
+    not invocation instanceof Operation and
+    not invocation instanceof AssocFunctionCall and
+    result = inferType(invocation.getArgument(pos), path)
   }
 
   bindingset[derefChainBorrow]
-  Type inferCallArgumentType(Call call, string derefChainBorrow, int pos, TypePath path) {
-    result = inferCallArgumentType0(call, pos, path)
+  Type inferInvocationArgumentType(
+    Invocation invocation, string derefChainBorrow, int pos, TypePath path
+  ) {
+    result = inferInvocationArgumentType0(invocation, pos, path)
     or
-    call =
+    invocation =
       any(AssocFunctionCall afc |
         result = afc.getInferredSelfType(pos, derefChainBorrow, path)
         or
@@ -754,12 +743,14 @@ private module Input3 implements InputSig3 {
   }
 
   pragma[nomagic]
-  private Type inferCallArgumentTypeContextualDefault(
-    Call call, int pos, AstNode n, DerefChain derefChain, BorrowKind borrow, TypePath path
+  private Type inferInvocationArgumentTypeContextualDefault(
+    Invocation invocation, int pos, AstNode n, DerefChain derefChain, BorrowKind borrow,
+    TypePath path
   ) {
     exists(string derefChainBorrow |
       decodeDerefChainBorrow(derefChainBorrow, derefChain, borrow) and
-      result = M3::inferCallArgumentTypeContextualDefault(call, derefChainBorrow, pos, n, path)
+      result =
+        M3::inferInvocationArgumentTypeContextualDefault(invocation, derefChainBorrow, pos, n, path)
     )
   }
 
@@ -771,13 +762,14 @@ private module Input3 implements InputSig3 {
    * empty, at which point the inferred type can be applied back to `n`.
    */
   pragma[nomagic]
-  private Type inferFunctionCallSelfArgumentTypeContextual(
-    Call call, AstNode n, DerefChain derefChain, TypePath path
+  private Type inferInvocationSelfArgumentTypeContextual(
+    Invocation invocation, AstNode n, DerefChain derefChain, TypePath path
   ) {
     exists(FunctionPosition pos, BorrowKind borrow, TypePath path0 |
-      call.(AssocFunctionResolution::AssocFunctionCall).hasReceiverAtPos(pos) and
+      invocation.(AssocFunctionResolution::AssocFunctionCall).hasReceiverAtPos(pos) and
       result =
-        inferCallArgumentTypeContextualDefault(call, pos.asPosition(), n, derefChain, borrow, path0)
+        inferInvocationArgumentTypeContextualDefault(invocation, pos.asPosition(), n, derefChain,
+          borrow, path0)
     |
       borrow.isNoBorrow() and
       path = path0
@@ -794,7 +786,7 @@ private module Input3 implements InputSig3 {
       DerefChain derefChain0, Type t0, TypePath path0, DerefImplItemNode impl, Type selfParamType,
       TypePath selfPath
     |
-      t0 = inferFunctionCallSelfArgumentTypeContextual(call, n, derefChain0, path0) and
+      t0 = inferInvocationSelfArgumentTypeContextual(invocation, n, derefChain0, path0) and
       derefChain0.isCons(impl, derefChain) and
       selfParamType = impl.resolveSelfTypeAt(selfPath)
     |
@@ -811,40 +803,41 @@ private module Input3 implements InputSig3 {
     )
   }
 
-  Type inferCallArgumentTypeContextual(AstNode n, TypePath path) {
-    exists(Call call, FunctionPosition pos, TypePath path0 |
-      result = inferCallArgumentTypeContextualDefault(call, pos.asPosition(), n, _, _, path0) and
-      not call.(AssocFunctionResolution::AssocFunctionCall).hasReceiverAtPos(pos)
+  Type inferInvocationArgumentTypeContextual(AstNode n, TypePath path) {
+    exists(Invocation invocation, FunctionPosition pos, TypePath path0 |
+      result =
+        inferInvocationArgumentTypeContextualDefault(invocation, pos.asPosition(), n, _, _, path0) and
+      not invocation.(AssocFunctionResolution::AssocFunctionCall).hasReceiverAtPos(pos)
       or
       pos.asPosition() = 0 and
-      result = inferFunctionCallSelfArgumentTypeContextual(call, n, DerefChain::nil(), path0) and
+      result = inferInvocationSelfArgumentTypeContextual(invocation, n, DerefChain::nil(), path0) and
       not path0.isEmpty()
     |
-      if call.(AssocFunctionResolution::OperationAssocFunctionCall).implicitBorrowAt(pos, _)
+      if invocation.(AssocFunctionResolution::OperationAssocFunctionCall).implicitBorrowAt(pos, _)
       then
         // adjust for implicit borrow
         path0.isCons(getRefTypeParameter(_), path)
       else path = path0
     )
   }
 
-  Type inferCallType(Call call, TypePath path) {
+  Type inferInvocationType(Invocation invocation, TypePath path) {
     exists(TypePath path0 |
-      result = M3::inferCallTypeDefault(call, _, path0) and
+      result = M3::inferInvocationTypeDefault(invocation, _, path0) and
       // index expression `x[i]` desugars to `*x.index(i)`, so we must account for
       // the implicit deref
-      if call instanceof IndexExpr or call instanceof DerefExpr
+      if invocation instanceof IndexExpr or invocation instanceof DerefExpr
       then path0.isCons(getRefTypeParameter(_), path)
       else path = path0
     )
   }
 
-  Type inferCallTypeContextual(Call call, TypePath path) {
+  Type inferInvocationTypeContextual(Invocation invocation, TypePath path) {
     exists(TypePath path0 |
-      result = inferType(call, path0) and
+      result = inferType(invocation, path0) and
       // index expression `x[i]` desugars to `*x.index(i)`, so we must account for
       // the implicit deref
-      if call instanceof IndexExpr or call instanceof DerefExpr
+      if invocation instanceof IndexExpr or invocation instanceof DerefExpr
       then path0.isCons(getRefTypeParameter(_), path)
       else path = path0
     )
@@ -3151,7 +3144,7 @@ private module DeconstructionPatMatchingInput implements MatchingInputSig {
       result = this.getParameter(pos.asPosition()).getType().getTypeAt(path)
       or
       pos.isReturn() and
-      result = Input3::getCallableReturnType(this, path)
+      result = Input3::getParameterizableType(this, path)
     }
   }
 

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

@@ -701,6 +701,20 @@ private module MkTypeMention<getAdditionalPathTypeAtSig/2 getAdditionalPathTypeA
   class InferTypeReprMention extends TypeMentionImpl, InferTypeRepr {
     override Type getTypeAt(TypePath path) { result = TUnknownType() and path.isEmpty() }
   }
+
+  /** A type item mention that resolves to itself. */
+  class TypeItemMention extends TypeMentionImpl instanceof TypeItem {
+    override Type getTypeAt(TypePath typePath) {
+      typePath.isEmpty() and
+      result = TDataType(this)
+      or
+      exists(TypeParam tp |
+        tp = this.(ItemNode).getTypeParam(_) and
+        typePath = TypePath::singleton(result) and
+        result = TTypeParamTypeParameter(tp)
+      )
+    }
+  }
 }
 
 private Type preGetAdditionalPathTypeAt(Path p, TypePath typePath) { none() }