member access

Author: hvitved

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

@@ -461,6 +461,72 @@ private module Input3 implements InputSig3 {
     )
   }
 
+  abstract class Member extends AstNode {
+    abstract TypeRepr getTypeRepr();
+
+    Type getDeclaringType(TypePath path) {
+      // no case for variants as those can only be destructured using pattern matching
+      exists(Struct s | this = [s.getStructField(_).(AstNode), s.getTupleField(_)] |
+        result = TDataType(s) and
+        path.isEmpty()
+        or
+        result = TTypeParamTypeParameter(s.getGenericParamList().getATypeParam()) and
+        path = TypePath::singleton(result)
+      )
+    }
+
+    Type getDeclaredType(TypePath path) {
+      result = this.getTypeRepr().(TypeMention).getTypeAt(path)
+    }
+  }
+
+  private class StructFieldDecl extends Member instanceof StructField {
+    override TypeRepr getTypeRepr() { result = StructField.super.getTypeRepr() }
+  }
+
+  private class TupleFieldDecl extends Member instanceof TupleField {
+    override TypeRepr getTypeRepr() { result = TupleField.super.getTypeRepr() }
+  }
+
+  class MemberAccess extends FieldExpr {
+    AstNode getReceiver() { result = this.getContainer() }
+
+    Member getMember() {
+      // mutual recursion; resolving fields requires resolving types and vice versa
+      result =
+        [
+          resolveStructFieldExpr(this, _).(AstNode),
+          resolveTupleFieldExpr(this, _)
+        ]
+    }
+  }
+
+  Type inferMemberAccessReceiverType(MemberAccess ma, TypePath path) {
+    exists(TypePath path0 | result = inferType(ma.getReceiver(), path0) |
+      // adjust for implicit deref
+      path0.isCons(getRefTypeParameter(_), path)
+      or
+      not path0.isCons(getRefTypeParameter(_), _) and
+      not (result instanceof RefType and path0.isEmpty()) and
+      path = path0
+    )
+  }
+
+  Type inferMemberAccessReceiverTypeContextual(AstNode n, TypePath path) {
+    exists(TypePath path0, Type receiverType |
+      result = M3::inferMemberAccessReceiverTypeContextualDefault(_, n, path0) and
+      receiverType = inferType(n)
+    |
+      if receiverType instanceof RefType
+      then
+        // adjust for implicit deref
+        not path0.isCons(getRefTypeParameter(_), _) and
+        not (path0.isEmpty() and result instanceof RefType) and
+        path = TypePath::cons(getRefTypeParameter(_), path0)
+      else path = path0
+    )
+  }
+
   predicate inferStepCertain(AstNode n1, TypePath path1, AstNode n2, TypePath path2) {
     n1 =
       any(IdentPat ip |
@@ -641,8 +707,6 @@ private module Input3 implements InputSig3 {
       result = inferOperationType(n, pos, path)
     )
     or
-    result = inferFieldExprType(n, path, false)
-    or
     result = inferTryExprType(n, path)
     or
     result = inferLiteralType(n, path, false)
@@ -668,8 +732,6 @@ private module Input3 implements InputSig3 {
       or
       result = inferOperationType(n, pos, path)
     )
-    or
-    result = inferFieldExprType(n, path, true)
   }
 }
 
@@ -2848,7 +2910,7 @@ private Type inferCallArgumentTypeContextual(
 ) {
   exists(string derefChainBorrow |
     FunctionCallMatchingInput::decodeDerefChainBorrow(derefChainBorrow, derefChain, borrow) and
-    result = M3::inferCallArgumentTypeContextual(call, derefChainBorrow, pos, n, path)
+    result = M3::inferCallArgumentTypeContextualDefault(call, derefChainBorrow, pos, n, path)
   )
 }
 
@@ -3218,161 +3280,6 @@ TupleField resolveTupleFieldExpr(FieldExpr fe, DerefChain derefChain) {
   )
 }
 
-/**
- * A matching configuration for resolving types of field expressions like `x.field`.
- */
-private module FieldExprMatchingInput implements MatchingInputSig {
-  private newtype TDeclarationPosition =
-    TSelfDeclarationPosition() or
-    TFieldPos()
-
-  class DeclarationPosition extends TDeclarationPosition {
-    predicate isSelf() { this = TSelfDeclarationPosition() }
-
-    predicate isField() { this = TFieldPos() }
-
-    string toString() {
-      this.isSelf() and
-      result = "self"
-      or
-      this.isField() and
-      result = "(field)"
-    }
-  }
-
-  private newtype TDeclaration =
-    TStructFieldDecl(StructField sf) or
-    TTupleFieldDecl(TupleField tf)
-
-  abstract class Declaration extends TDeclaration {
-    TypeParameter getTypeParameter(TypeParameterPosition ppos) { none() }
-
-    abstract Type getDeclaredType(DeclarationPosition dpos, TypePath path);
-
-    abstract string toString();
-
-    abstract Location getLocation();
-  }
-
-  abstract private class StructOrTupleFieldDecl extends Declaration {
-    abstract AstNode getAstNode();
-
-    abstract TypeRepr getTypeRepr();
-
-    override Type getDeclaredType(DeclarationPosition dpos, TypePath path) {
-      dpos.isSelf() and
-      // no case for variants as those can only be destructured using pattern matching
-      exists(Struct s | this.getAstNode() = [s.getStructField(_).(AstNode), s.getTupleField(_)] |
-        result = TDataType(s) and
-        path.isEmpty()
-        or
-        result = TTypeParamTypeParameter(s.getGenericParamList().getATypeParam()) and
-        path = TypePath::singleton(result)
-      )
-      or
-      dpos.isField() and
-      result = this.getTypeRepr().(TypeMention).getTypeAt(path)
-    }
-
-    override string toString() { result = this.getAstNode().toString() }
-
-    override Location getLocation() { result = this.getAstNode().getLocation() }
-  }
-
-  private class StructFieldDecl extends StructOrTupleFieldDecl, TStructFieldDecl {
-    private StructField sf;
-
-    StructFieldDecl() { this = TStructFieldDecl(sf) }
-
-    override AstNode getAstNode() { result = sf }
-
-    override TypeRepr getTypeRepr() { result = sf.getTypeRepr() }
-  }
-
-  private class TupleFieldDecl extends StructOrTupleFieldDecl, TTupleFieldDecl {
-    private TupleField tf;
-
-    TupleFieldDecl() { this = TTupleFieldDecl(tf) }
-
-    override AstNode getAstNode() { result = tf }
-
-    override TypeRepr getTypeRepr() { result = tf.getTypeRepr() }
-  }
-
-  class AccessPosition = DeclarationPosition;
-
-  class Access extends FieldExpr {
-    Type getTypeArgument(TypeArgumentPosition apos, TypePath path) { none() }
-
-    AstNode getNodeAt(AccessPosition apos) {
-      result = this.getContainer() and
-      apos.isSelf()
-      or
-      result = this and
-      apos.isField()
-    }
-
-    Type getInferredType(AccessPosition apos, TypePath path) {
-      exists(TypePath path0 | result = inferType(this.getNodeAt(apos), path0) |
-        if apos.isSelf()
-        then
-          // adjust for implicit deref
-          path0.isCons(getRefTypeParameter(_), path)
-          or
-          not path0.isCons(getRefTypeParameter(_), _) and
-          not (result instanceof RefType and path0.isEmpty()) and
-          path = path0
-        else path = path0
-      )
-    }
-
-    Declaration getTarget() {
-      // mutual recursion; resolving fields requires resolving types and vice versa
-      result =
-        [
-          TStructFieldDecl(resolveStructFieldExpr(this, _)).(TDeclaration),
-          TTupleFieldDecl(resolveTupleFieldExpr(this, _))
-        ]
-    }
-  }
-
-  predicate accessDeclarationPositionMatch(AccessPosition apos, DeclarationPosition dpos) {
-    apos = dpos
-  }
-}
-
-private module FieldExprMatching = Matching<FieldExprMatchingInput>;
-
-/**
- * Gets the type of `n` at `path`, where `n` is either a field expression or
- * the receiver of field expression call.
- */
-pragma[nomagic]
-private Type inferFieldExprType(AstNode n, TypePath path, boolean topDown) {
-  exists(
-    FieldExprMatchingInput::Access a, FieldExprMatchingInput::AccessPosition apos, TypePath path0
-  |
-    n = a.getNodeAt(apos) and
-    result = FieldExprMatching::inferAccessType(a, apos, path0)
-  |
-    if apos.isSelf()
-    then
-      topDown = true and
-      exists(Type receiverType | receiverType = inferType(n) |
-        if receiverType instanceof RefType
-        then
-          // adjust for implicit deref
-          not path0.isCons(getRefTypeParameter(_), _) and
-          not (path0.isEmpty() and result instanceof RefType) and
-          path = TypePath::cons(getRefTypeParameter(_), path0)
-        else path = path0
-      )
-    else (
-      topDown = false and path = path0
-    )
-  )
-}
-
 /** Gets the root type of the reference expression `ref`. */
 pragma[nomagic]
 private Type inferRefExprType(RefExpr ref) {