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

pkg/front_end/lib/src/fasta/type_inference/type_inferrer.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.md file.
 
 import 'package:front_end/src/base/instrumentation.dart';
 import 'package:front_end/src/fasta/errors.dart' show internalError;
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart';
 import 'package:front_end/src/fasta/names.dart' show callName;
 import 'package:front_end/src/fasta/type_inference/type_inference_engine.dart';
 import 'package:front_end/src/fasta/type_inference/type_inference_listener.dart';
@@ skipping 205 matching lines @@
   final ClassHierarchy classHierarchy;
 
   final Instrumentation instrumentation;
 
   final TypeSchemaEnvironment typeSchemaEnvironment;
 
   final TypeInferenceListener listener;
 
   final InterfaceType thisType;
 
-  /// The [FieldNode] whose initializer will be type inferred using this
+  /// The [AccessorNode] whose type will be type inferred using this
   /// [TypeInferrerImpl], or `null` if this [TypeInferrerImpl] will be used to
-  /// infer types outside the scope of a field initializer.
-  final FieldNode fieldNode;
+  /// infer types outside the scope of top level type inference.
+  final AccessorNode accessorNode;
 
   /// Context information for the current closure, or `null` if we are not
   /// inside a closure.
   ClosureContext closureContext;
 
   /// When performing top level inference, this boolean is set to `false` if we
   /// discover that the type of the object is not immediately evident.
   ///
   /// Not used when performing local inference.
   bool isImmediatelyEvident = true;
 
-  List<FieldNode> _dryRunDependencies;
+  List<AccessorNode> _dryRunDependencies;
 
   TypeInferrerImpl(this.engine, this.uri, this.listener, bool topLevel,
-      this.thisType, this.fieldNode)
+      this.thisType, this.accessorNode)
       : coreTypes = engine.coreTypes,
         strongMode = engine.strongMode,
         classHierarchy = engine.classHierarchy,
         instrumentation = topLevel ? null : engine.instrumentation,
         typeSchemaEnvironment = engine.typeSchemaEnvironment,
         isTopLevel = topLevel;
 
   /// Indicates whether we are currently doing a "dry run" in order to collect
   /// type inference dependencies.
   bool get isDryRun => _dryRunDependencies != null;
@@ skipping 89 matching lines @@
       propertySet.interfaceTarget = interfaceMember;
       return interfaceMember;
     } else {
       throw internalError(
           'Unexpected propertySet type: ${propertySet.runtimeType}');
     }
   }
 
   /// Ends a dry run started by [startDryRun] and returns the collected
   /// dependencies.
-  List<FieldNode> finishDryRun() {
+  List<AccessorNode> finishDryRun() {
     var dryRunDependencies = _dryRunDependencies;
     _dryRunDependencies = null;
     return dryRunDependencies;
   }
 
   FunctionType getCalleeFunctionType(Member interfaceMember,
       DartType receiverType, Name methodName, bool followCall) {
     var type = getCalleeType(interfaceMember, receiverType, methodName);
     if (type is FunctionType) {
       return type;
@@ skipping 276 matching lines @@
     // First infer the receiver so we can look up the getter that was invoked.
     var receiverType = inferExpression(receiver, null, true);
     Member interfaceMember =
         findInterfaceMember(receiverType, desugaredGet.name, fileOffset);
     if (isTopLevel &&
         ((interfaceMember is Procedure &&
                 interfaceMember.kind == ProcedureKind.Getter) ||
             interfaceMember is Field)) {
       if (TypeInferenceEngineImpl.fullTopLevelInference) {
         if (interfaceMember is KernelField) {
-          var fieldNode = KernelMember.getFieldNode(interfaceMember);
-          if (fieldNode != null) {
-            engine.inferFieldFused(fieldNode, this.fieldNode);
+          var accessorNode = KernelMember.getAccessorNode(interfaceMember);
+          if (accessorNode != null) {
+            engine.inferAccessorFused(accessorNode, this.accessorNode);
           }
         }
       } else {
         // References to fields and getters can't be relied upon for top level
         // inference.
         recordNotImmediatelyEvident(fileOffset);
       }
     }
     desugaredGet.interfaceTarget = interfaceMember;
     var inferredType =
@@ skipping 19 matching lines @@
     }
     return returnType;
   }
 
   /// Performs type inference on the given [statement].
   ///
   /// Derived classes should override this method with logic that dispatches on
   /// the statement type and calls the appropriate specialized "infer" method.
   void inferStatement(Statement statement);
 
-  /// Records that the field represented by [fieldNode] is a dependency of the
-  /// static field for which we are currently doing a dry run of type inference.
+  /// Records that the accessor represented by [accessorNode] is a dependency of
+  /// the accessor for which we are currently doing a dry run of type inference.
   ///
   /// May only be called if a dry run is in progress.
-  void recordDryRunDependency(FieldNode fieldNode) {
-    listener.recordDependency(fieldNode);
-    _dryRunDependencies.add(fieldNode);
+  void recordDryRunDependency(AccessorNode accessorNode) {
+    listener.recordDependency(accessorNode);
+    _dryRunDependencies.add(accessorNode);
   }
 
   void recordNotImmediatelyEvident(int fileOffset) {
     assert(isTopLevel);
     isImmediatelyEvident = false;
     // TODO(paulberry): report an error.
   }
 
   /// Begins a dry run of type inference, in which the goal is to collect the
-  /// dependencies of a given field.
+  /// dependencies of a given accessor.
   void startDryRun() {
     assert(_dryRunDependencies == null);
-    _dryRunDependencies = <FieldNode>[];
+    _dryRunDependencies = <AccessorNode>[];
   }
 
   DartType wrapFutureOrType(DartType type) {
     if (type is InterfaceType &&
         identical(type.classNode, coreTypes.futureOrClass)) {
       return type;
     }
     // TODO(paulberry): If [type] is a subtype of `Future`, should we just
     // return it unmodified?
     return new InterfaceType(
@@ skipping 17 matching lines @@
   void _forEachArgument(
       Arguments arguments, void callback(String name, Expression expression)) {
     for (var expression in arguments.positional) {
       callback(null, expression);
     }
     for (var namedExpression in arguments.named) {
       callback(namedExpression.name, namedExpression.value);
     }
   }
 }