Rename "field" -> "accessor" in several type inference methods.

pkg/front_end/lib/src/fasta/kernel/kernel_shadow_ast.dart

 // Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /// This file declares a "shadow hierarchy" of concrete classes which extend
 /// the kernel class hierarchy, adding methods and fields needed by the
 /// BodyBuilder.
 ///
 /// Instances of these classes may be created using the factory methods in
 /// `ast_factory.dart`.
@@ skipping 644 matching lines @@
         computeConstructorReturnType(_initialTarget),
         arguments);
     inferrer.listener.constructorInvocationExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Concrete shadow object representing a field in kernel form.
 class KernelField extends Field implements KernelMember {
   @override
-  FieldNode _fieldNode;
+  AccessorNode _accessorNode;
 
   @override
   KernelTypeInferrer _typeInferrer;
 
   KernelField(Name name, {String fileUri}) : super(name, fileUri: fileUri) {}
 
   @override
   void setInferredType(
       TypeInferenceEngineImpl engine, String uri, DartType inferredType) {
     engine.instrumentation?.record(Uri.parse(uri), fileOffset, 'topType',
@@ skipping 629 matching lines @@
         : null;
     inferrer.listener.mapLiteralExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Abstract shadow object representing a field or procedure in kernel form.
 abstract class KernelMember implements Member {
   String get fileUri;
 
-  FieldNode get _fieldNode;
+  AccessorNode get _accessorNode;
 
-  void set _fieldNode(FieldNode value);
+  void set _accessorNode(AccessorNode value);
 
   KernelTypeInferrer get _typeInferrer;
 
   void set _typeInferrer(KernelTypeInferrer value);
 
   void setInferredType(
       TypeInferenceEngineImpl engine, String uri, DartType inferredType);
 
-  static FieldNode getFieldNode(Member member) {
-    if (member is KernelMember) return member._fieldNode;
+  static AccessorNode getAccessorNode(Member member) {
+    if (member is KernelMember) return member._accessorNode;
     return null;
   }
 
   static void recordOverride(KernelMember member, Member overriddenMember) {
-    if (member._fieldNode != null) {
-      member._fieldNode.overrides.add(overriddenMember);
+    if (member._accessorNode != null) {
+      member._accessorNode.overrides.add(overriddenMember);
     }
   }
 }
 
 /// Shadow object for [MethodInvocation].
 class KernelMethodInvocation extends MethodInvocation
     implements KernelExpression {
   /// Indicates whether this method invocation is a call to a `call` method
   /// resulting from the invocation of a function expression.
   final bool _isImplicitCall;
@@ skipping 118 matching lines @@
         inferrer.listener.nullLiteralEnter(this, typeContext) || typeNeeded;
     var inferredType = typeNeeded ? inferrer.coreTypes.nullClass.rawType : null;
     inferrer.listener.nullLiteralExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Concrete shadow object representing a procedure in kernel form.
 class KernelProcedure extends Procedure implements KernelMember {
   @override
-  FieldNode _fieldNode;
+  AccessorNode _accessorNode;
 
   @override
   KernelTypeInferrer _typeInferrer;
 
   KernelProcedure(Name name, ProcedureKind kind, FunctionNode function,
       {String fileUri})
       : super(name, kind, function, fileUri: fileUri);
 
   @override
   void setInferredType(
@@ skipping 46 matching lines @@
       inferrer.findPropertyGetMember(receiverType, read, silent: true);
     }
     Member writeMember;
     if (write != null) {
       writeMember = inferrer.findPropertySetMember(receiverType, write);
       if (inferrer.isTopLevel &&
           ((writeMember is Procedure &&
                   writeMember.kind == ProcedureKind.Setter) ||
               writeMember is Field)) {
         if (TypeInferenceEngineImpl.fullTopLevelInference) {
-          if (writeMember is KernelField && writeMember._fieldNode != null) {
-            inferrer.engine
-                .inferFieldFused(writeMember._fieldNode, inferrer.fieldNode);
+          if (writeMember is KernelField && writeMember._accessorNode != null) {
+            inferrer.engine.inferAccessorFused(
+                writeMember._accessorNode, inferrer.accessorNode);
           }
         } else {
           // References to fields and setters can't be relied upon for top level
           // inference.
           inferrer.recordNotImmediatelyEvident(fileOffset);
         }
       }
     }
     // To replicate analyzer behavior, we base type inference on the write
     // member.  TODO(paulberry): would it be better to use the read member when
@@ skipping 113 matching lines @@
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded = inferrer.listener.staticAssignEnter(desugared, typeContext) ||
         typeNeeded;
     // TODO(paulberry): record the appropriate types on let variables and
     // conditional expressions.
     DartType writeContext;
     var write = this.write;
     if (write is StaticSet) {
       writeContext = write.target.setterType;
       var target = write.target;
-      if (target is KernelField && target._fieldNode != null) {
+      if (target is KernelField && target._accessorNode != null) {
         if (inferrer.isDryRun) {
-          inferrer.recordDryRunDependency(target._fieldNode);
+          inferrer.recordDryRunDependency(target._accessorNode);
         }
         if (TypeInferenceEngineImpl.fusedTopLevelInference &&
             inferrer.isTopLevel) {
           inferrer.engine
-              .inferFieldFused(target._fieldNode, inferrer.fieldNode);
+              .inferAccessorFused(target._accessorNode, inferrer.accessorNode);
         }
       }
     }
     var inferredType = _inferRhs(inferrer, writeContext);
     inferrer.listener.staticAssignExit(desugared, inferredType);
     return inferredType;
   }
 }
 
 /// Concrete shadow object representing a read of a static variable in kernel
 /// form.
 class KernelStaticGet extends StaticGet implements KernelExpression {
   KernelStaticGet(Member target) : super(target);
 
   @override
   void _collectDependencies(KernelDependencyCollector collector) {
     // A simple or qualified identifier referring to a top level function,
     // static variable, field, getter; or a static class variable, static getter
     // or method; or an instance method; has the inferred type of the referent.
     // - Otherwise, if the identifier has no inferred or annotated type then it
     //   is an error.
     // - Note: specifically, references to instance fields and instance getters
     //   are disallowed here.
     // - The inference dependency of the identifier is the referent if the
     //   referent is a candidate for inference.  Otherwise there are no
     //   inference dependencies.
     // TODO(paulberry): implement the proper error checking logic.
     var target = this.target;
-    if (target is KernelField && target._fieldNode != null) {
-      collector.recordDependency(target._fieldNode);
+    if (target is KernelField && target._accessorNode != null) {
+      collector.recordDependency(target._accessorNode);
     }
   }
 
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.staticGetEnter(this, typeContext) || typeNeeded;
     var target = this.target;
-    if (target is KernelField && target._fieldNode != null) {
+    if (target is KernelField && target._accessorNode != null) {
       if (inferrer.isDryRun) {
-        inferrer.recordDryRunDependency(target._fieldNode);
+        inferrer.recordDryRunDependency(target._accessorNode);
       }
       if (TypeInferenceEngineImpl.fusedTopLevelInference &&
           inferrer.isTopLevel) {
-        inferrer.engine.inferFieldFused(target._fieldNode, inferrer.fieldNode);
+        inferrer.engine
+            .inferAccessorFused(target._accessorNode, inferrer.accessorNode);
       }
     }
     var inferredType = typeNeeded ? target.getterType : null;
     inferrer.listener.staticGetExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Shadow object for [StaticInvocation].
 class KernelStaticInvocation extends StaticInvocation
@@ skipping 174 matching lines @@
   }
 }
 
 /// Concrete implementation of [TypeInferenceEngine] specialized to work with
 /// kernel objects.
 class KernelTypeInferenceEngine extends TypeInferenceEngineImpl {
   KernelTypeInferenceEngine(Instrumentation instrumentation, bool strongMode)
       : super(instrumentation, strongMode);
 
   @override
-  FieldNode createFieldNode(KernelMember member) {
-    FieldNode fieldNode = new FieldNode(this, member);
-    member._fieldNode = fieldNode;
-    return fieldNode;
+  AccessorNode createAccessorNode(KernelMember member) {
+    AccessorNode accessorNode = new AccessorNode(this, member);
+    member._accessorNode = accessorNode;
+    return accessorNode;
   }
 
   @override
   KernelTypeInferrer createLocalTypeInferrer(
       Uri uri, TypeInferenceListener listener, InterfaceType thisType) {
     return new KernelTypeInferrer._(
         this, uri.toString(), listener, false, thisType, null);
   }
 
   @override
   KernelTypeInferrer createTopLevelTypeInferrer(TypeInferenceListener listener,
       InterfaceType thisType, KernelMember member) {
     return member._typeInferrer = new KernelTypeInferrer._(
-        this, member.fileUri, listener, true, thisType, member._fieldNode);
+        this, member.fileUri, listener, true, thisType, member._accessorNode);
   }
 
   @override
-  KernelTypeInferrer getFieldTypeInferrer(KernelMember member) {
+  KernelTypeInferrer getMemberTypeInferrer(KernelMember member) {
     return member._typeInferrer;
   }
 }
 
 /// Concrete implementation of [TypeInferrer] specialized to work with kernel
 /// objects.
 class KernelTypeInferrer extends TypeInferrerImpl {
   @override
   final typePromoter = new KernelTypePromoter();
 
   KernelTypeInferrer._(
       KernelTypeInferenceEngine engine,
       String uri,
       TypeInferenceListener listener,
       bool topLevel,
       InterfaceType thisType,
-      FieldNode fieldNode)
-      : super(engine, uri, listener, topLevel, thisType, fieldNode);
+      AccessorNode accessorNode)
+      : super(engine, uri, listener, topLevel, thisType, accessorNode);
 
   @override
   Expression getFieldInitializer(KernelField field) {
     return field.initializer;
   }
 
   @override
   DartType inferExpression(
       Expression expression, DartType typeContext, bool typeNeeded) {
     // When doing top level inference, we skip subexpressions whose type isn't
@@ skipping 302 matching lines @@
   }
 
   transformChildren(v) {
     return internalError("Internal error: Unsupported operation.");
   }
 
   visitChildren(v) {
     return internalError("Internal error: Unsupported operation.");
   }
 }