@@ -451,6 +451,8 @@ module Unified {
    */
   final class GetterDeclaration extends AccessorDeclaration {
     GetterDeclaration() { this.getAccessorKind().getValue() = "get" }
+
+    override string getNameOrFallback() { result = "get_" + this.getNameNode().getValue() }
   }
 
   /**
@@ -466,6 +468,8 @@ module Unified {
    */
   final class SetterDeclaration extends AccessorDeclaration {
     SetterDeclaration() { this.getAccessorKind().getValue() = "set" }
+
+    override string getNameOrFallback() { result = "set_" + this.getNameNode().getValue() }
   }
 
   /** An `if` statement or conditional expression. */
 
@@ -179,6 +179,35 @@ private module LocalNameBindingInput implements LocalNameBindingInputSig<Locatio
     any(NameBindingPlugin p).isNonPattern(e)
   }
 
+  pragma[nomagic]
+  private predicate accessorInScope(AstNode scope, string name, AccessorDeclaration accessor) {
+    getChild(scope, _) = accessor and
+    name = accessor.getName()
+  }
+
+  pragma[nomagic]
+  private predicate variableDeclarationInScope(AstNode scope, string name, VariableDeclaration decl) {
+    getChild(scope, _) = decl and
+    name = decl.getName()
+  }
+
+  /**
+   * Holds if the given accessor has a backing field with the same name.
+   *
+   * In this case we resolve all accesses to the field instead of any of the
+   * accessors using the field.
+   */
+  additional predicate hasBackingField(AccessorDeclaration accessor) {
+    exists(AstNode scope, string name, VariableDeclaration decl |
+      accessorInScope(scope, name, accessor) and
+      variableDeclarationInScope(scope, name, decl) and
+      (isInstanceMember(decl) implies isInstanceMember(accessor)) and
+      (isInstanceMember(accessor) implies isInstanceMember(decl)) and
+      (isStaticMember(decl) implies isStaticMember(accessor)) and
+      (isStaticMember(accessor) implies isStaticMember(decl))
+    )
+  }
+
   cached
   additional predicate bindingContext(AstNode pattern, AstNode scope, AstNode declaration) {
     LocalNameBindingOutput::CachedStage::ref() and
@@ -253,6 +282,7 @@ private module LocalNameBindingInput implements LocalNameBindingInputSig<Locatio
       )
       or
       exists(AccessorDeclaration decl |
+        not hasBackingField(decl) and
         getChild(scope, _) = decl and
         pattern = decl.getNameNode() and
         declaration = decl
@@ -474,6 +504,10 @@ module Public {
  * ```
  */
 class PotentialLocalNameAccess extends IdentifierExpr {
+  PotentialLocalNameAccess() {
+    not this = any(AccessorDeclaration a | LocalNameBindingInput::hasBackingField(a)).getNameNode()
+  }
+
   /** Gets the representative for the local name being accessed. */
   LocalName getLocalName() { result = this.(LocalNameBindingOutput::LocalAccess).getLocal() }
 
 
@@ -81,7 +81,9 @@ predicate isInstanceMember(Member member) {
   (
     member instanceof VariableDeclaration or
     member instanceof FunctionDeclaration or
-    member instanceof ConstructorDeclaration
+    member instanceof ConstructorDeclaration or
+    member instanceof GetterDeclaration or
+    member instanceof SetterDeclaration
   ) and
   exists(ClassLikeDeclaration cls | cls.getAMember() = member |
     any(NameBindingPlugin p).isInstanceMember(cls, member)
 
@@ -123,6 +123,8 @@ module Input3 implements InputSig3 {
   predicate cacheRevRef() {
     (exists(resolveFieldAccess(_)) implies any())
     or
+    (exists(resolveAccessorAccess(_)) implies any())
+    or
     (exists(resolveCallTarget(_)) implies any())
   }
 
@@ -252,24 +254,55 @@ module Input3 implements InputSig3 {
     override Location getLocation() { result = decl.getLocation() }
   }
 
-  class Field extends AstVariableDeclaration {
+  final class Field = FieldImpl;
+
+  abstract private class FieldImpl extends DeclarationImpl {
+    abstract AstNode getAstNode();
+  }
+
+  private class VariableDeclarationField extends FieldImpl, AstVariableDeclaration {
     ClassLikeDeclaration cls;
 
-    Field() { decl = cls.getAMember() }
+    VariableDeclarationField() { decl = cls.getAMember() }
+
+    override AstNode getAstNode() { result = this.getDecl() }
 
     override TypeMention getDeclaringType() { result = getClassLikeDeclarationTypeMention(cls) }
   }
 
-  private class EnumField_ extends Field {
+  private class EnumField_ extends VariableDeclarationField {
     override EnumField decl;
 
     override TypeMention getType() { result = decl.getEnum().getNameNode() }
   }
 
+  private class AccessorField extends FieldImpl, Callable {
+    private AccessorDeclaration accessor;
+
+    AccessorField() { accessor = this.getCallable() }
+
+    override TypeMention getType() { result = accessor.getType() }
+
+    override AstNode getAstNode() { result = accessor }
+  }
+
   abstract class FieldAccess extends Expr {
     abstract Expr getReceiver();
 
-    abstract Field getField();
+    abstract Field getFieldImpl();
+
+    Field getField() {
+      result = this.getFieldImpl() and
+      (
+        result instanceof VariableDeclaration
+        or
+        hasIncomingValue(this, _) and
+        result.getAstNode() instanceof SetterDeclaration
+        or
+        hasResultValue(this) and
+        result.getAstNode() instanceof GetterDeclaration
+      )
+    }
   }
 
   pragma[nomagic]
@@ -296,14 +329,14 @@ module Input3 implements InputSig3 {
       name = this.getMemberName()
     }
 
-    override Field getField() {
+    override Field getFieldImpl() {
       // mutual recursion; resolving qualified fields requires resolving types and vice versa
       result = lookupInstanceMember(this)
       or
       // also mutual recursion
       exists(TupleType tuple, string name |
         this.isTupleProjection(tuple, name) and
-        result.getDecl() = tuple.getField(name)
+        result.getAstNode() = tuple.getField(name)
       )
       or
       // no mutual recursion; can be resolved directly with static name binding
@@ -322,7 +355,19 @@ module Input3 implements InputSig3 {
   private class UnqualifiedMemberAccessFieldAccess extends FieldAccess, UnqualifiedMemberAccess {
     override Expr getReceiver() { none() }
 
-    override Field getField() { result.getNameNode() = this.getTarget() }
+    override Field getFieldImpl() { result.getNameNode() = this.getTarget() }
+  }
+
+  private class LocalAccessorFieldAccess extends FieldAccess, LocalNameAccess {
+    AccessorDeclaration target;
+
+    LocalAccessorFieldAccess() {
+      target = getStaticBindingTargetFromIdentifier(this).getDeclaration()
+    }
+
+    override Expr getReceiver() { none() }
+
+    override Field getFieldImpl() { result.getAstNode() = target }
   }
 
   Type inferFieldAccessReceiverType(FieldAccess fa, TypePath path) {
@@ -506,17 +551,21 @@ module Input3 implements InputSig3 {
     }
 
     Callable getTargetImpl(boolean isFunctionExprInvoke) {
-      // mutual recursion; call with explicit receiver: `obj.foo(42)`
-      result = lookupInstanceMember(this.getCallee()) and
-      isFunctionExprInvoke = false
-      or
-      // mutual recursion; call to a function expression: `callback(42)`
-      result.asCallable() = this.getInvokeTarget(_) and
-      isFunctionExprInvoke = true
-      or
-      // no mutual recursion; can be resolved directly with static name binding
-      result = this.getTargetViaStaticNameBinding() and
-      isFunctionExprInvoke = false
+      (
+        // mutual recursion; call with explicit receiver: `obj.foo(42)`
+        result = lookupInstanceMember(this.getCallee()) and
+        isFunctionExprInvoke = false
+        or
+        // mutual recursion; call to a function expression: `callback(42)`
+        result.asCallable() = this.getInvokeTarget(_) and
+        isFunctionExprInvoke = true
+        or
+        // no mutual recursion; can be resolved directly with static name binding
+        result = this.getTargetViaStaticNameBinding() and
+        isFunctionExprInvoke = false
+      ) and
+      // handled as a field access
+      not result.asCallable() instanceof AccessorDeclaration
     }
 
     Callable getTarget(InvocationResolutionContext c) {
@@ -835,7 +884,19 @@ module CachedStage = M3::CachedStage;
 cached
 VariableDeclaration resolveFieldAccess(Expr access) {
   CachedStage::ref() and
-  result = access.(Input3::FieldAccess).getField().getDecl()
+  result = access.(Input3::FieldAccess).getField().getAstNode()
+}
+
+/**
+ * Gets the accessor that is accessed by the given expression.
+ *
+ * `access` is either a `MemberAccessExpr` or an `Identifier` (when
+ * the field is accessed with an implicit receiver).
+ */
+cached
+AccessorDeclaration resolveAccessorAccess(Expr access) {
+  CachedStage::ref() and
+  result = access.(Input3::FieldAccess).getField().getAstNode()
 }
 
 /**
 
@@ -24,7 +24,11 @@ abstract private class TypeMentionImpl extends AstNode {
 final class ExprTypeMention = ExprTypeMentionImpl;
 
 abstract private class ExprTypeMentionImpl extends TypeMentionImpl, Expr {
-  ExprTypeMentionImpl() { isInTypeContext(this) and not this instanceof GenericTypeExpr }
+  ExprTypeMentionImpl() {
+    isInTypeContext(this) and
+    not this instanceof GenericTypeExpr and
+    not this instanceof ModifiedTypeExpr
+  }
 
   pragma[nomagic]
   abstract TypePath getTypeArgumentPath(int i);
@@ -191,6 +195,14 @@ private class ClassLikeDeclarationTypeMention extends TypeMentionImpl, Identifie
   }
 }
 
+private class ModifiedTypeExprMention extends TypeMentionImpl instanceof ModifiedTypeExpr {
+  private TypeMention base;
+
+  ModifiedTypeExprMention() { base = ModifiedTypeExpr.super.getType() }
+
+  override Type getTypeAt(TypePath path) { result = base.getTypeAt(path) }
+}
+
 TypeMention getClassLikeDeclarationTypeMention(ClassLikeDeclaration c) {
   result = c.getNameNode()
   or