wip

Author: hvitved

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

@@ -816,9 +816,9 @@ private Type getCallExprTypeQualifier(CallExpr ce, TypePath path) {
  * `i`, and the type at position `pos` is `t`.
  */
 pragma[nomagic]
-private predicate functionInfo(
+private predicate assocFunctionInfo(
   Function f, string name, int arity, ImplOrTraitItemNode i, FunctionTypePosition pos,
-  FunctionType t
+  AssocFunctionType t
 ) {
   f = i.getASuccessor(name) and
   arity = f.getParamList().getNumberOfParams() and
@@ -836,10 +836,10 @@ private predicate functionInfo(
 pragma[nomagic]
 private predicate functionInfoBlanket(
   Function f, string name, int arity, ImplItemNode impl, Trait trait, FunctionTypePosition pos,
-  FunctionType t, TypePath blanketPath, TypeParam blanketTypeParam
+  AssocFunctionType t, TypePath blanketPath, TypeParam blanketTypeParam
 ) {
   exists(TypePath blanketSelfPath |
-    functionInfo(f, name, arity, impl, pos, t) and
+    assocFunctionInfo(f, name, arity, impl, pos, t) and
     TTypeParamTypeParameter(blanketTypeParam) = t.getTypeAt(blanketPath) and
     blanketPath = any(string s) + blanketSelfPath and
     BlanketImplementation::isBlanketLike(impl, blanketSelfPath, blanketTypeParam) and
@@ -914,11 +914,11 @@ private module MethodResolution {
    */
   pragma[nomagic]
   private predicate methodInfo(
-    Method m, string name, int arity, ImplOrTraitItemNode i, FunctionType selfType,
+    Method m, string name, int arity, ImplOrTraitItemNode i, AssocFunctionType selfType,
     TypePath strippedTypePath, Type strippedType
   ) {
     exists(FunctionTypePosition pos |
-      functionInfo(m, name, arity, i, pos, selfType) and
+      assocFunctionInfo(m, name, arity, i, pos, selfType) and
       strippedType = selfType.getTypeAt(strippedTypePath) and
       isComplexRootStripped(strippedTypePath, strippedType) and
       pos.isSelf()
@@ -927,7 +927,7 @@ private module MethodResolution {
 
   pragma[nomagic]
   private predicate methodInfoTypeParam(
-    Method m, string name, int arity, ImplOrTraitItemNode i, FunctionType selfType,
+    Method m, string name, int arity, ImplOrTraitItemNode i, AssocFunctionType selfType,
     TypePath strippedTypePath, TypeParam tp
   ) {
     methodInfo(m, name, arity, i, selfType, strippedTypePath, TTypeParamTypeParameter(tp))
@@ -940,7 +940,7 @@ private module MethodResolution {
    */
   pragma[inline]
   private predicate methodInfoNonBlanket(
-    Method m, string name, int arity, ImplOrTraitItemNode i, FunctionType selfType,
+    Method m, string name, int arity, ImplOrTraitItemNode i, AssocFunctionType selfType,
     TypePath strippedTypePath, Type strippedType
   ) {
     (
@@ -960,7 +960,7 @@ private module MethodResolution {
    */
   pragma[nomagic]
   private predicate methodInfoBlanket(
-    Method m, string name, int arity, ImplItemNode impl, Trait trait, FunctionType selfType,
+    Method m, string name, int arity, ImplItemNode impl, Trait trait, AssocFunctionType selfType,
     TypePath blanketPath, TypeParam blanketTypeParam
   ) {
     exists(FunctionTypePosition pos |
@@ -1017,8 +1017,8 @@ private module MethodResolution {
   bindingset[mc, strippedTypePath, strippedType]
   pragma[inline_late]
   private predicate methodCallNonBlanketCandidate(
-    MethodCall mc, Method m, ImplOrTraitItemNode i, FunctionType self, TypePath strippedTypePath,
-    Type strippedType
+    MethodCall mc, Method m, ImplOrTraitItemNode i, AssocFunctionType self,
+    TypePath strippedTypePath, Type strippedType
   ) {
     exists(string name, int arity |
       mc.hasNameAndArity(name, arity) and
@@ -1051,7 +1051,7 @@ private module MethodResolution {
   bindingset[mc]
   pragma[inline_late]
   private predicate methodCallBlanketCandidate(
-    MethodCall mc, Method m, ImplItemNode impl, FunctionType self, TypePath blanketPath,
+    MethodCall mc, Method m, ImplItemNode impl, AssocFunctionType self, TypePath blanketPath,
     TypeParam blanketTypeParam
   ) {
     exists(string name, int arity |
@@ -1478,6 +1478,8 @@ private module MethodResolution {
       MethodArgsAreInstantiationsOf::argsAreInstantiationsOf(this, _, result)
     }
 
+    predicate hasNoBorrow() { not derefChainBorrow = any(string s) + ";borrow" }
+
     string toString() { result = mc_.toString() + " [" + derefChainBorrow + "]" }
 
     Location getLocation() { result = mc_.getLocation() }
@@ -1497,20 +1499,28 @@ private module MethodResolution {
         // this is to account for codebases that use the (unstable) specialization feature
         // (https://rust-lang.github.io/rfcs/1210-impl-specialization.html)
         mcc.hasNoCompatibleTarget()
+      |
+        mcc.hasNoBorrow()
+        or
+        blanketPath.getHead() = TRefTypeParameter()
       )
     }
   }
 
+  private module ReceiverSatisfiesBlanketConstraint =
+    BlanketImplementation::SatisfiesBlanketConstraint<MethodCallCand,
+      ReceiverSatisfiesBlanketConstraintInput>;
+
   /**
    * A configuration for matching the type of a receiver against the type of
    * a `self` parameter.
    */
   private module ReceiverIsInstantiationOfSelfParamInput implements
-    IsInstantiationOfInputSig<MethodCallCand, FunctionType>
+    IsInstantiationOfInputSig<MethodCallCand, AssocFunctionType>
   {
     pragma[nomagic]
     additional predicate potentialInstantiationOf0(
-      MethodCallCand mcc, ImplOrTraitItemNode i, FunctionType selfType
+      MethodCallCand mcc, ImplOrTraitItemNode i, AssocFunctionType selfType
     ) {
       exists(
         MethodCall mc, Method m, string name, int arity, TypePath strippedTypePath,
@@ -1521,14 +1531,13 @@ private module MethodResolution {
         methodCallNonBlanketCandidate(mc, m, i, selfType, strippedTypePath, strippedType)
         or
         methodCallBlanketCandidate(mc, m, i, selfType, _, _) and
-        BlanketImplementation::SatisfiesBlanketConstraint<MethodCallCand, ReceiverSatisfiesBlanketConstraintInput>::satisfiesBlanketConstraint(mcc,
-          i)
+        ReceiverSatisfiesBlanketConstraint::satisfiesBlanketConstraint(mcc, i)
       )
     }
 
     pragma[nomagic]
     predicate potentialInstantiationOf(
-      MethodCallCand mcc, TypeAbstraction abs, FunctionType constraint
+      MethodCallCand mcc, TypeAbstraction abs, AssocFunctionType constraint
     ) {
       potentialInstantiationOf0(mcc, abs, constraint) and
       if abs.(Impl).hasTrait()
@@ -1539,7 +1548,7 @@ private module MethodResolution {
       else any()
     }
 
-    predicate relevantTypeMention(FunctionType constraint) {
+    predicate relevantTypeMention(AssocFunctionType constraint) {
       methodInfo(_, _, _, _, constraint, _, _)
     }
   }
@@ -1589,17 +1598,17 @@ private module MethodResolution {
    * a `self` parameter in an inherent method.
    */
   private module ReceiverIsNotInstantiationOfInherentSelfParamInput implements
-    IsInstantiationOfInputSig<MethodCallCand, FunctionType>
+    IsInstantiationOfInputSig<MethodCallCand, AssocFunctionType>
   {
     pragma[nomagic]
     predicate potentialInstantiationOf(
-      MethodCallCand mcc, TypeAbstraction abs, FunctionType constraint
+      MethodCallCand mcc, TypeAbstraction abs, AssocFunctionType constraint
     ) {
       ReceiverIsInstantiationOfSelfParamInput::potentialInstantiationOf0(mcc, abs, constraint) and
       abs = any(Impl i | not i.hasTrait())
     }
 
-    predicate relevantTypeMention(FunctionType constraint) {
+    predicate relevantTypeMention(AssocFunctionType constraint) {
       methodInfo(_, _, _, _, constraint, _, _)
     }
   }
@@ -1612,7 +1621,9 @@ private module MethodResolution {
    * types of parameters, when needed to disambiguate the call.
    */
   private module MethodArgsAreInstantiationsOfInput implements ArgsAreInstantiationsOfInputSig {
-    predicate toCheck(ImplOrTraitItemNode i, Function f, FunctionTypePosition pos, FunctionType t) {
+    predicate toCheck(
+      ImplOrTraitItemNode i, Function f, FunctionTypePosition pos, AssocFunctionType t
+    ) {
       exists(TypePath path, Type t0 |
         pos.isPositional() and
         FunctionOverloading::functionResolutionDependsOnArgument(i, f, pos, path, t0) and
@@ -1837,7 +1848,7 @@ private module NonMethodResolution {
     ImplItemNode impl, NonMethodFunction implFunction
   ) {
     exists(TypePath path |
-      functionTypeAtPath(implFunction, impl, pos, path, type) and
+      assocFunctionTypeAtPath(implFunction, impl, pos, path, type) and
       implFunction.implements(traitFunction) and
       FunctionOverloading::traitTypeParameterOccurrence(trait, traitFunction, _, pos, path, _)
     |
@@ -1857,7 +1868,7 @@ private module NonMethodResolution {
   pragma[nomagic]
   private predicate functionInfoBlanketRelevantPos(
     NonMethodFunction f, string name, int arity, ImplItemNode impl, Trait trait,
-    FunctionTypePosition pos, FunctionType t, TypePath blanketPath, TypeParam blanketTypeParam
+    FunctionTypePosition pos, AssocFunctionType t, TypePath blanketPath, TypeParam blanketTypeParam
   ) {
     functionInfoBlanket(f, name, arity, impl, trait, pos, t, blanketPath, blanketTypeParam) and
     (
@@ -1895,7 +1906,7 @@ private module NonMethodResolution {
     NonMethodCall fc, NonMethodFunction f, ImplItemNode impl, FunctionTypePosition pos,
     TypePath blanketPath, TypeParam blanketTypeParam
   ) {
-    exists(string name, int arity, Trait trait, FunctionType t |
+    exists(string name, int arity, Trait trait, AssocFunctionType t |
       fc.hasNameAndArity(name, arity) and
       exists(getTypeAt(fc, pos, blanketPath)) and
       functionInfoBlanketRelevantPos(f, name, arity, impl, trait, pos, t, blanketPath,
@@ -1937,24 +1948,28 @@ private module NonMethodResolution {
     }
   }
 
+  private module ArgSatisfiesBlanketConstraint =
+    BlanketImplementation::SatisfiesBlanketConstraint<CallAndPos, ArgSatisfiesBlanketConstraintInput>;
+
   /**
    * A configuration for matching the type of an argument against the type of
    * a parameter that mentions a satisfied blanket type parameter.
    */
   private module ArgIsInstantiationOfBlanketParamInput implements
-    IsInstantiationOfInputSig<CallAndPos, FunctionType>
+    IsInstantiationOfInputSig<CallAndPos, AssocFunctionType>
   {
     pragma[nomagic]
-    predicate potentialInstantiationOf(CallAndPos fcp, TypeAbstraction abs, FunctionType constraint) {
+    predicate potentialInstantiationOf(
+      CallAndPos fcp, TypeAbstraction abs, AssocFunctionType constraint
+    ) {
       exists(FunctionTypePosition pos |
-        BlanketImplementation::SatisfiesBlanketConstraint<CallAndPos, ArgSatisfiesBlanketConstraintInput>::satisfiesBlanketConstraint(fcp,
-          abs) and
+        ArgSatisfiesBlanketConstraint::satisfiesBlanketConstraint(fcp, abs) and
         fcp = MkCallAndPos(_, pos) and
         functionInfoBlanketRelevantPos(_, _, _, abs, _, pos, constraint, _, _)
       )
     }
 
-    predicate relevantTypeMention(FunctionType constraint) {
+    predicate relevantTypeMention(AssocFunctionType constraint) {
       functionInfoBlanketRelevantPos(_, _, _, _, _, _, constraint, _, _)
     }
   }
@@ -2047,7 +2062,9 @@ private module NonMethodResolution {
   }
 
   private module NonMethodArgsAreInstantiationsOfInput implements ArgsAreInstantiationsOfInputSig {
-    predicate toCheck(ImplOrTraitItemNode i, Function f, FunctionTypePosition pos, FunctionType t) {
+    predicate toCheck(
+      ImplOrTraitItemNode i, Function f, FunctionTypePosition pos, AssocFunctionType t
+    ) {
       t.appliesTo(f, pos, i) and
       (
         exists(Type t0 |
@@ -2980,9 +2997,9 @@ private module Cached {
    */
   cached
   StructField resolveStructFieldExpr(FieldExpr fe) {
-    exists(string name, Type ty | ty = getFieldExprLookupType(fe, name) |
-      result = ty.(StructType).getStruct().getStructField(name) or
-      result = ty.(UnionType).getUnion().getStructField(name)
+    exists(string name, Type ty | ty = getFieldExprLookupType(fe, pragma[only_bind_into](name)) |
+      result = ty.(StructType).getStruct().getStructField(pragma[only_bind_into](name)) or
+      result = ty.(UnionType).getUnion().getStructField(pragma[only_bind_into](name))
     )
   }
 
@@ -2992,7 +3009,11 @@ private module Cached {
   cached
   TupleField resolveTupleFieldExpr(FieldExpr fe) {
     exists(int i |
-      result = getTupleFieldExprLookupType(fe, i).(StructType).getStruct().getTupleField(i)
+      result =
+        getTupleFieldExprLookupType(fe, pragma[only_bind_into](i))
+            .(StructType)
+            .getStruct()
+            .getTupleField(pragma[only_bind_into](i))
     )
   }
 
@@ -3150,9 +3171,14 @@ private module Debug {
     result = strictcount(Type t0 | t0 = inferType(n, path))
   }
 
+  pragma[nomagic]
+  private predicate atLimit(AstNode n) {
+    exists(TypePath path0 | exists(inferType(n, path0)) and path0.length() >= getTypePathLimit())
+  }
+
   Type debugInferTypeForNodeAtLimit(AstNode n, TypePath path) {
     result = inferType(n, path) and
-    exists(TypePath path0 | exists(inferType(n, path0)) and path0.length() >= getTypePathLimit())
+    atLimit(n)
   }
 
   predicate countTypesForNodeAtLimit(AstNode n, int c) {

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

@@ -79,7 +79,7 @@ predicate traitTypeParameterOccurrence(
   TypeParameter tp
 ) {
   f = trait.getASuccessor(functionName) and
-  functionTypeAtPath(f, trait, pos, path, tp) and
+  assocFunctionTypeAtPath(f, trait, pos, path, tp) and
   tp = trait.(TraitTypeAbstraction).getATypeParameter()
 }
 
@@ -120,7 +120,7 @@ predicate functionResolutionDependsOnArgument(
   exists(TraitItemNode trait, string functionName |
     implHasSibling(impl, trait) and
     traitTypeParameterOccurrence(trait, _, functionName, pos, path, _) and
-    functionTypeAtPath(f, impl, pos, path, type) and
+    assocFunctionTypeAtPath(f, impl, pos, path, type) and
     f = impl.getASuccessor(functionName) and
     not pos.isReturn()
   )