Rename BuilderAccessor to FastaAccessor.

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

 // Copyright (c) 2016, 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.
 
 library fasta.body_builder;
 
 import '../parser/parser.dart' show FormalParameterType, optional;
 
 import '../parser/error_kind.dart' show ErrorKind;
 
@@ skipping 19 matching lines @@
 
 import '../errors.dart' show formatUnexpected, internalError;
 
 import '../source/scope_listener.dart'
     show JumpTargetKind, NullValue, ScopeListener;
 
 import '../builder/scope.dart' show ProblemBuilder, Scope;
 
 import '../source/outline_builder.dart' show asyncMarkerFromTokens;
 
-import 'builder_accessors.dart';
+import 'fasta_accessors.dart';
 
 import '../quote.dart'
     show
         Quote,
         analyzeQuote,
         unescape,
         unescapeFirstStringPart,
         unescapeLastStringPart,
         unescapeString;
 
@@ skipping 97 matching lines @@
       if (isDartLibrary &&
           node.name.name == "main" &&
           library.uri.path == "_builtin" &&
           member?.name == "_getMainClosure") {
         // TODO(ahe): https://github.com/dart-lang/sdk/issues/28989
         return new NullLiteral()..fileOffset = node.fileOffset;
       }
       return throwNoSuchMethodError(
           node.name.name, new Arguments.empty(), node.fileOffset,
           isGetter: true);
-    } else if (node is BuilderAccessor) {
+    } else if (node is FastaAccessor) {
       return node.buildSimpleRead();
     } else if (node is TypeVariableBuilder) {
       TypeParameterType type = node.buildTypesWithBuiltArguments(library, null);
       if (!isInstanceContext && type.parameter.parent is Class) {
         return buildCompileTimeError(
             "Type variables can only be used in instance methods.");
       } else {
         if (constantExpressionRequired) {
           addCompileTimeError(-1,
               "Type variable can't be used as a constant expression $type.");
         }
         return new TypeLiteral(type);
       }
     } else if (node is TypeDeclarationBuilder) {
       return new TypeLiteral(node.buildTypesWithBuiltArguments(library, null));
     } else if (node is KernelTypeBuilder) {
       return new TypeLiteral(node.build(library));
     } else if (node is Expression) {
       return node;
     } else if (node is PrefixBuilder) {
       return buildCompileTimeError("A library can't be used as an expression.");
     } else if (node is ProblemBuilder) {
       return buildProblemExpression(node, -1);
     } else {
       return internalError("Unhandled: ${node.runtimeType}");
     }
   }
 
   Expression toEffect(Object node) {
-    if (node is BuilderAccessor) return node.buildForEffect();
+    if (node is FastaAccessor) return node.buildForEffect();
     return toValue(node);
   }
 
   List<Expression> popListForValue(int n) {
     List<Expression> list =
         new List<Expression>.filled(n, null, growable: true);
     for (int i = n - 1; i >= 0; i--) {
       list[i] = popForValue();
     }
     return list;
@@ skipping 183 matching lines @@
 
   @override
   void endInitializer(Token token) {
     debugEvent("endInitializer");
     assert(!inInitializer);
     final member = this.member;
     var node = pop();
     Initializer initializer;
     if (node is Initializer) {
       initializer = node;
-    } else if (node is BuilderAccessor) {
+    } else if (node is FastaAccessor) {
       initializer = node.buildFieldInitializer(fieldInitializers);
     } else if (node is ConstructorInvocation) {
       initializer = new SuperInitializer(node.target, node.arguments);
     } else {
       if (node is! Throw) {
         node = wrapInvalid(node);
       }
       initializer =
           new LocalInitializer(new VariableDeclaration.forValue(node));
     }
@@ skipping 114 matching lines @@
   }
 
   @override
   finishSend(Object receiver, Arguments arguments, int charOffset) {
     bool isIdentical(Object receiver) {
       return receiver is StaticAccessor &&
           receiver.readTarget ==
               coreTypes.tryGetTopLevelMember("dart:core", null, "identical");
     }
 
-    if (receiver is BuilderAccessor) {
+    if (receiver is FastaAccessor) {
       if (constantExpressionRequired && !isIdentical(receiver)) {
         addCompileTimeError(charOffset, "Not a constant expression.");
       }
       return receiver.doInvocation(charOffset, arguments);
     } else if (receiver is UnresolvedIdentifier) {
       return throwNoSuchMethodError(
           receiver.name.name, arguments, receiver.fileOffset);
     } else {
       return buildMethodInvocation(
           toValue(receiver), callName, arguments, charOffset);
@@ skipping 491 matching lines @@
   }
 
   @override
   void handleAssignmentExpression(Token token) {
     debugEvent("AssignmentExpression");
     Expression value = popForValue();
     var accessor = pop();
     if (accessor is TypeDeclarationBuilder) {
       push(wrapInvalid(new TypeLiteral(
           accessor.buildTypesWithBuiltArguments(library, null))));
-    } else if (accessor is! BuilderAccessor) {
+    } else if (accessor is! FastaAccessor) {
       push(buildCompileTimeError("Can't assign to this.", token.charOffset));
     } else {
       push(new DelayedAssignment(
           this, token.charOffset, accessor, value, token.stringValue));
     }
   }
 
   @override
   void enterLoop(int charOffset) {
     if (peek() is LabelTarget) {
@@ skipping 24 matching lines @@
     Statement conditionStatement = popStatement();
     Expression condition = null;
     if (conditionStatement is ExpressionStatement) {
       condition = conditionStatement.expression;
     } else {
       assert(conditionStatement is EmptyStatement);
     }
     List<VariableDeclaration> variables = <VariableDeclaration>[];
     dynamic variableOrExpression = pop();
     Statement begin;
-    if (variableOrExpression is BuilderAccessor) {
+    if (variableOrExpression is FastaAccessor) {
       variableOrExpression = variableOrExpression.buildForEffect();
     }
     if (variableOrExpression is VariableDeclaration) {
       variables.add(variableOrExpression);
     } else if (variableOrExpression is List) {
       // TODO(sigmund): remove this assignment (see issue #28651)
       Iterable vars = variableOrExpression;
       variables.addAll(vars);
     } else if (variableOrExpression == null) {
       // Do nothing.
@@ skipping 191 matching lines @@
       } else {
         push(const DynamicType());
         addCompileTimeError(beginToken.charOffset,
             "Can't be used as a type: '${debugName(prefix, suffix)}'.");
         return;
       }
     }
     if (name is Identifier) {
       name = name.name;
     }
-    if (name is BuilderAccessor) {
+    if (name is FastaAccessor) {
       warning("'${beginToken.lexeme}' isn't a type.", beginToken.charOffset);
       push(const DynamicType());
     } else if (name is UnresolvedIdentifier) {
       warning("'${name.name}' isn't a type.", beginToken.charOffset);
       push(const DynamicType());
     } else if (name is TypeVariableBuilder) {
       if (constantExpressionRequired) {
         addCompileTimeError(
             beginToken.charOffset, "Not a constant expression.");
       }
@@ skipping 286 matching lines @@
   Name incrementOperator(Token token) {
     if (optional("++", token)) return plusName;
     if (optional("--", token)) return minusName;
     return internalError("Unknown increment operator: ${token.lexeme}");
   }
 
   @override
   void handleUnaryPrefixAssignmentExpression(Token token) {
     debugEvent("UnaryPrefixAssignmentExpression");
     var accessor = pop();
-    if (accessor is BuilderAccessor) {
+    if (accessor is FastaAccessor) {
       push(accessor.buildPrefixIncrement(incrementOperator(token),
           offset: token.charOffset));
     } else {
       push(wrapInvalid(toValue(accessor)));
     }
   }
 
   @override
   void handleUnaryPostfixAssignmentExpression(Token token) {
     debugEvent("UnaryPostfixAssignmentExpression");
     var accessor = pop();
-    if (accessor is BuilderAccessor) {
+    if (accessor is FastaAccessor) {
       push(new DelayedPostfixIncrement(
           this, token.charOffset, accessor, incrementOperator(token), null));
     } else {
       push(wrapInvalid(toValue(accessor)));
     }
   }
 
   @override
   void endConstructorReference(
       Token start, Token periodBeforeName, Token endToken) {
@@ skipping 352 matching lines @@
     exitLocalScope();
     JumpTarget continueTarget = exitContinueTarget();
     JumpTarget breakTarget = exitBreakTarget();
     if (continueTarget.hasUsers) {
       body = new LabeledStatement(body);
       continueTarget.resolveContinues(body);
     }
     VariableDeclaration variable;
     if (lvalue is VariableDeclaration) {
       variable = lvalue;
-    } else if (lvalue is BuilderAccessor) {
+    } else if (lvalue is FastaAccessor) {
       /// We are in this case, where `lvalue` isn't a [VariableDeclaration]:
       ///
       ///     for (lvalue in expression) body
       ///
       /// This is normalized to:
       ///
       ///     for (final #t in expression) {
       ///       lvalue = #t;
       ///       body;
       ///     }
@@ skipping 480 matching lines @@
     nextCascade = newCascade;
   }
 
   void finalize(Expression expression) {
     assert(nextCascade.variable.initializer is InvalidExpression);
     nextCascade.variable.initializer = expression;
     expression.parent = nextCascade.variable;
   }
 }
 
-abstract class ContextAccessor extends BuilderAccessor {
+abstract class ContextAccessor extends FastaAccessor {
   final BuilderHelper helper;
 
-  final BuilderAccessor accessor;
+  final FastaAccessor accessor;
 
   final int offset;
 
   ContextAccessor(this.helper, this.offset, this.accessor);
 
   @override
   Expression get builtBinary => internalError("Unsupported operation.");
 
   @override
   void set builtBinary(Expression expression) {
@@ skipping 55 matching lines @@
         "Can't be used as left-hand side of assignment.", offset);
   }
 }
 
 class DelayedAssignment extends ContextAccessor {
   final Expression value;
 
   final String assignmentOperator;
 
   DelayedAssignment(BuilderHelper helper, int charOffset,
-      BuilderAccessor accessor, this.value, this.assignmentOperator)
+      FastaAccessor accessor, this.value, this.assignmentOperator)
       : super(helper, charOffset, accessor);
 
   Expression buildSimpleRead() {
     return handleAssignment(false);
   }
 
   Expression buildForEffect() {
     return handleAssignment(true);
   }
 
@@ skipping 57 matching lines @@
     return accessor.buildFieldInitializer(initializers);
   }
 }
 
 class DelayedPostfixIncrement extends ContextAccessor {
   final Name binaryOperator;
 
   final Procedure interfaceTarget;
 
   DelayedPostfixIncrement(BuilderHelper helper, int offset,
-      BuilderAccessor accessor, this.binaryOperator, this.interfaceTarget)
+      FastaAccessor accessor, this.binaryOperator, this.interfaceTarget)
       : super(helper, offset, accessor);
 
   Expression buildSimpleRead() {
     return accessor.buildPostfixIncrement(binaryOperator,
         offset: offset, voidContext: false, interfaceTarget: interfaceTarget);
   }
 
   Expression buildForEffect() {
     return accessor.buildPostfixIncrement(binaryOperator,
         offset: offset, voidContext: true, interfaceTarget: interfaceTarget);
@@ skipping 216 matching lines @@
   if (node is Identifier) {
     return node.name;
   } else if (node is UnresolvedIdentifier) {
     return node.name.name;
   } else if (node is TypeDeclarationBuilder) {
     return node.name;
   } else if (node is PrefixBuilder) {
     return node.name;
   } else if (node is ThisAccessor) {
     return node.isSuper ? "super" : "this";
-  } else if (node is BuilderAccessor) {
+  } else if (node is FastaAccessor) {
     return node.plainNameForRead;
   } else {
     return internalError("Unhandled: ${node.runtimeType}");
   }
 }