wip

Author: hvitved

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

@@ -5,68 +5,110 @@ private import TypeAbstraction
 private import TypeMention
 private import TypeInference
 
-private newtype TFunctionPosition =
-  TArgumentFunctionPosition(ArgumentPosition pos) or
-  TReturnFunctionPosition()
+private signature predicate includeSelfSig();
+
+private module MkFunctionPosition<includeSelfSig/0 includeSelf> {
+  private newtype TFunctionPosition =
+    TArgumentFunctionPosition(ArgumentPosition pos) {
+      if pos.isSelf() then includeSelf() else any()
+    } or
+    TReturnFunctionPosition()
+
+  class FunctionPosition extends TFunctionPosition {
+    int asPosition() { result = this.asArgumentPosition().asPosition() }
+
+    predicate isPosition() { exists(this.asPosition()) }
+
+    ArgumentPosition asArgumentPosition() { this = TArgumentFunctionPosition(result) }
+
+    predicate isTypeQualifier() { this.asArgumentPosition().isTypeQualifier() }
+
+    predicate isReturn() { this = TReturnFunctionPosition() }
+
+    TypeMention getTypeMention(Function f) {
+      result = f.getParam(this.asPosition()).getTypeRepr()
+      or
+      this.isReturn() and
+      result = getReturnTypeMention(f)
+    }
+
+    string toString() {
+      result = this.asArgumentPosition().toString()
+      or
+      this.isReturn() and
+      result = "(return)"
+    }
+  }
+}
+
+private predicate any_() { any() }
 
 /**
  * A position of a type related to a function.
  *
  * Either `self`, `return`, or a positional parameter index.
  */
-class FunctionPosition extends TFunctionPosition {
+final class FunctionPosition extends MkFunctionPosition<any_/0>::FunctionPosition {
   predicate isSelf() { this.asArgumentPosition().isSelf() }
 
-  int asPosition() { result = this.asArgumentPosition().asPosition() }
-
-  predicate isPosition() { exists(this.asPosition()) }
-
-  ArgumentPosition asArgumentPosition() { this = TArgumentFunctionPosition(result) }
-
-  predicate isTypeQualifier() { this.asArgumentPosition().isTypeQualifier() }
-
   predicate isSelfOrTypeQualifier() { this.isSelf() or this.isTypeQualifier() }
 
-  predicate isReturn() { this = TReturnFunctionPosition() }
+  override TypeMention getTypeMention(Function f) {
+    result = super.getTypeMention(f)
+    or
+    this.isSelf() and
+    result = getSelfParamTypeMention(f.getSelfParam())
+  }
 
   /**
    * Gets the corresponding position when function call syntax is used, assuming
    * this position is for a method.
    */
-  FunctionPosition getFunctionCallAdjusted() {
-    (this.isReturn() or this.isTypeQualifier()) and
-    result = this
+  pragma[nomagic]
+  FunctionPositionAdj getFunctionCallAdjusted() {
+    this.isReturn() and result.isReturn()
+    or
+    this.isTypeQualifier() and
+    result.isTypeQualifier()
     or
     this.isSelf() and result.asPosition() = 0
     or
     result.asPosition() = this.asPosition() + 1
   }
 
+  /**
+   * Gets the corresponding position when function call syntax is used, assuming
+   * this position is _not_ for a method.
+   */
+  pragma[nomagic]
+  FunctionPositionAdj asAdjusted() {
+    this.isReturn() and result.isReturn()
+    or
+    this.isTypeQualifier() and
+    result.isTypeQualifier()
+    or
+    result.asPosition() = this.asPosition()
+  }
+
   /**
    * Gets the corresponding position when `f` is invoked via function call
    * syntax.
    */
   bindingset[f]
-  FunctionPosition getFunctionCallAdjusted(Function f) {
-    if f.hasSelfParam() then result = this.getFunctionCallAdjusted() else result = this
+  FunctionPositionAdj getFunctionCallAdjusted(Function f) {
+    if f.hasSelfParam() then result = this.getFunctionCallAdjusted() else result = this.asAdjusted()
   }
+}
 
-  TypeMention getTypeMention(Function f) {
-    this.isSelf() and
-    result = getSelfParamTypeMention(f.getSelfParam())
-    or
-    result = f.getParam(this.asPosition()).getTypeRepr()
-    or
-    this.isReturn() and
-    result = getReturnTypeMention(f)
-  }
+private predicate none_() { none() }
 
-  string toString() {
-    result = this.asArgumentPosition().toString()
-    or
-    this.isReturn() and
-    result = "(return)"
-  }
+/**
+ * A function-call adjust position of a type related to a function.
+ *
+ * Either `return` or a positional parameter index.
+ */
+final class FunctionPositionAdj extends MkFunctionPosition<none_/0>::FunctionPosition {
+  FunctionPosition asNonAdjusted() { this = result.asAdjusted() }
 }
 
 /**
@@ -83,6 +125,20 @@ module FunctionPositionMatchingInput {
   }
 }
 
+/**
+ * A helper module for implementing `Matching(WithEnvironment)InputSig` with
+ * `DeclarationPosition = AccessPosition = FunctionPositionAdj`.
+ */
+module FunctionPositionAdjMatchingInput {
+  class DeclarationPosition = FunctionPositionAdj;
+
+  class AccessPosition = DeclarationPosition;
+
+  predicate accessDeclarationPositionMatch(AccessPosition apos, DeclarationPosition dpos) {
+    apos = dpos
+  }
+}
+
 private newtype TAssocFunctionType =
   /** An associated function `f` in `parent` should be specialized for `i` at `pos`. */
   MkAssocFunctionType(
@@ -323,15 +379,15 @@ signature module ArgsAreInstantiationsOfInputSig {
    * `posAdj` is one of the function-call adjusted positions in `f` in which the relevant
    * type occurs.
    */
-  predicate toCheck(ImplOrTraitItemNode i, Function f, TypeParameter tp, FunctionPosition posAdj);
+  predicate toCheck(ImplOrTraitItemNode i, Function f, TypeParameter tp, FunctionPositionAdj posAdj);
 
   /** A call whose argument types are to be checked. */
   class Call {
     string toString();
 
     Location getLocation();
 
-    Type getArgType(FunctionPosition posAdj, TypePath path);
+    Type getArgType(FunctionPositionAdj posAdj, TypePath path);
 
     predicate hasTargetCand(ImplOrTraitItemNode i, Function f);
   }
@@ -345,7 +401,7 @@ signature module ArgsAreInstantiationsOfInputSig {
 module ArgsAreInstantiationsOf<ArgsAreInstantiationsOfInputSig Input> {
   pragma[nomagic]
   private predicate toCheckRanked(
-    ImplOrTraitItemNode i, Function f, TypeParameter tp, FunctionPosition posAdj, int rnk
+    ImplOrTraitItemNode i, Function f, TypeParameter tp, FunctionPositionAdj posAdj, int rnk
   ) {
     Input::toCheck(i, f, tp, posAdj) and
     tp =
@@ -359,7 +415,7 @@ module ArgsAreInstantiationsOf<ArgsAreInstantiationsOfInputSig Input> {
 
   pragma[nomagic]
   private predicate toCheck(
-    ImplOrTraitItemNode i, Function f, TypeParameter tp, FunctionPosition posAdj,
+    ImplOrTraitItemNode i, Function f, TypeParameter tp, FunctionPositionAdj posAdj,
     AssocFunctionType t
   ) {
     exists(FunctionPosition pos |
@@ -370,20 +426,20 @@ module ArgsAreInstantiationsOf<ArgsAreInstantiationsOfInputSig Input> {
   }
 
   private newtype TCallAndPosAdj =
-    MkCallAndPosAdj(Input::Call call, FunctionPosition posAdj) {
+    MkCallAndPosAdj(Input::Call call, FunctionPositionAdj posAdj) {
       exists(call.getArgType(posAdj, _))
     }
 
   /** A call tagged with a function-call adjusted position. */
   private class CallAndPosAdj extends MkCallAndPosAdj {
     Input::Call call;
-    FunctionPosition posAdj;
+    FunctionPositionAdj posAdj;
 
     CallAndPosAdj() { this = MkCallAndPosAdj(call, posAdj) }
 
     Input::Call getCall() { result = call }
 
-    FunctionPosition getPosAdj() { result = posAdj }
+    FunctionPositionAdj getPosAdj() { result = posAdj }
 
     Location getLocation() { result = call.getLocation() }
 
@@ -394,7 +450,7 @@ module ArgsAreInstantiationsOf<ArgsAreInstantiationsOfInputSig Input> {
 
   pragma[nomagic]
   private predicate potentialInstantiationOf0(
-    CallAndPosAdj cp, Input::Call call, TypeParameter tp, FunctionPosition posAdj, Function f,
+    CallAndPosAdj cp, Input::Call call, TypeParameter tp, FunctionPositionAdj posAdj, Function f,
     TypeAbstraction abs, AssocFunctionType constraint
   ) {
     cp = MkCallAndPosAdj(call, pragma[only_bind_into](posAdj)) and
@@ -409,7 +465,7 @@ module ArgsAreInstantiationsOf<ArgsAreInstantiationsOfInputSig Input> {
     predicate potentialInstantiationOf(
       CallAndPosAdj cp, TypeAbstraction abs, AssocFunctionType constraint
     ) {
-      exists(Input::Call call, TypeParameter tp, FunctionPosition posAdj, int rnk, Function f |
+      exists(Input::Call call, TypeParameter tp, FunctionPositionAdj posAdj, int rnk, Function f |
         potentialInstantiationOf0(cp, call, tp, posAdj, f, abs, constraint) and
         toCheckRanked(abs, f, tp, posAdj, rnk)
       |
@@ -429,7 +485,7 @@ module ArgsAreInstantiationsOf<ArgsAreInstantiationsOfInputSig Input> {
   private predicate argIsInstantiationOf(
     Input::Call call, ImplOrTraitItemNode i, Function f, int rnk
   ) {
-    exists(FunctionPosition posAdj |
+    exists(FunctionPositionAdj posAdj |
       ArgIsInstantiationOfToIndex::argIsInstantiationOf(MkCallAndPosAdj(call, posAdj), i, _) and
       toCheckRanked(i, f, _, posAdj, rnk)
     )
@@ -480,7 +536,7 @@ module ArgsAreInstantiationsOf<ArgsAreInstantiationsOfInputSig Input> {
 
   pragma[nomagic]
   private predicate argsAreNotInstantiationsOf0(
-    Input::Call call, FunctionPosition posAdj, ImplOrTraitItemNode i
+    Input::Call call, FunctionPositionAdj posAdj, ImplOrTraitItemNode i
   ) {
     ArgsAreNotInstantiationOf::argIsNotInstantiationOf(MkCallAndPosAdj(call, posAdj), i, _, _)
   }
@@ -493,7 +549,7 @@ module ArgsAreInstantiationsOf<ArgsAreInstantiationsOfInputSig Input> {
    */
   pragma[nomagic]
   predicate argsAreNotInstantiationsOf(Input::Call call, ImplOrTraitItemNode i, Function f) {
-    exists(FunctionPosition posAdj |
+    exists(FunctionPositionAdj posAdj |
       argsAreNotInstantiationsOf0(call, posAdj, i) and
       call.hasTargetCand(i, f) and
       Input::toCheck(i, f, _, posAdj)