Rename front end shadow classes from "Kernel..." to "Shadow...".

pkg/front_end/lib/src/fasta/kernel/fasta_accessors.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.fasta_accessors;
 
 import 'package:kernel/ast.dart'
     hide InvalidExpression, InvalidInitializer, InvalidStatement;
 
 import '../../scanner/token.dart' show Token;
@@ skipping 27 matching lines @@
     show
         Builder,
         KernelClassBuilder,
         KernelInvalidTypeBuilder,
         LibraryBuilder,
         PrefixBuilder,
         TypeDeclarationBuilder;
 
 import 'kernel_shadow_ast.dart'
     show
-        KernelArguments,
-        KernelComplexAssignment,
-        KernelIllegalAssignment,
-        KernelIndexAssign,
-        KernelPropertyAssign,
-        KernelStaticAssignment,
-        KernelThisExpression,
-        KernelTypeLiteral,
-        KernelVariableAssignment;
+        ShadowArguments,
+        ShadowComplexAssignment,
+        ShadowIllegalAssignment,
+        ShadowIndexAssign,
+        ShadowPropertyAssign,
+        ShadowStaticAssignment,
+        ShadowThisExpression,
+        ShadowTypeLiteral,
+        ShadowVariableAssignment;
 
 import 'utils.dart' show offsetForToken;
 
 abstract class BuilderHelper {
   LibraryBuilder get library;
 
   Uri get uri;
 
   TypePromoter get typePromoter;
 
@@ skipping 91 matching lines @@
   Expression makeInvalidRead() {
     return buildThrowNoSuchMethodError(
         new NullLiteral()..fileOffset = offsetForToken(token),
         new Arguments.empty(),
         isGetter: true);
   }
 
   Expression makeInvalidWrite(Expression value) {
     return buildThrowNoSuchMethodError(
         new NullLiteral()..fileOffset = offsetForToken(token),
-        new KernelArguments(<Expression>[value]),
+        new ShadowArguments(<Expression>[value]),
         isSetter: true);
   }
 
   /* Expression | FastaAccessor | Initializer */ doInvocation(
       int offset, Arguments arguments);
 
   /* Expression | FastaAccessor */ buildPropertyAccess(
       IncompleteSend send, int operatorOffset, bool isNullAware) {
     if (send is SendAccessor) {
       return helper.buildMethodInvocation(buildSimpleRead(), send.name,
@@ skipping 21 matching lines @@
         arguments, offset ?? offsetForToken(this.token),
         isGetter: isGetter,
         isSetter: isSetter,
         isSuper: isSuper,
         isStatic: isStatic);
   }
 
   bool get isThisPropertyAccessor => false;
 
   @override
-  KernelComplexAssignment startComplexAssignment(Expression rhs) =>
-      new KernelIllegalAssignment(rhs);
+  ShadowComplexAssignment startComplexAssignment(Expression rhs) =>
+      new ShadowIllegalAssignment(rhs);
 }
 
 abstract class ErrorAccessor implements FastaAccessor {
   /// Pass [arguments] that must be evaluated before throwing an error.  At
   /// most one of [isGetter] and [isSetter] should be true and they're passed
   /// to [BuilderHelper.buildThrowNoSuchMethodError] if it is used.
   Expression buildError(Arguments arguments,
       {bool isGetter: false, bool isSetter: false, int offset});
 
   Name get name => unsupported("name", offsetForToken(token), uri);
@@ skipping 26 matching lines @@
       bool isGetter: false,
       bool isSetter: false,
       bool isStatic: false,
       String name,
       int offset}) {
     return this;
   }
 
   @override
   Expression buildAssignment(Expression value, {bool voidContext: false}) {
-    return buildError(new KernelArguments(<Expression>[value]), isSetter: true);
+    return buildError(new ShadowArguments(<Expression>[value]), isSetter: true);
   }
 
   @override
   Expression buildCompoundAssignment(Name binaryOperator, Expression value,
       {int offset: TreeNode.noOffset,
       bool voidContext: false,
       Procedure interfaceTarget,
       bool isPreIncDec: false}) {
-    return buildError(new KernelArguments(<Expression>[value]), isGetter: true);
+    return buildError(new ShadowArguments(<Expression>[value]), isGetter: true);
   }
 
   @override
   Expression buildPrefixIncrement(Name binaryOperator,
       {int offset: TreeNode.noOffset,
       bool voidContext: false,
       Procedure interfaceTarget}) {
-    return buildError(new KernelArguments(<Expression>[new IntLiteral(1)]),
+    return buildError(new ShadowArguments(<Expression>[new IntLiteral(1)]),
         isGetter: true);
   }
 
   @override
   Expression buildPostfixIncrement(Name binaryOperator,
       {int offset: TreeNode.noOffset,
       bool voidContext: false,
       Procedure interfaceTarget}) {
-    return buildError(new KernelArguments(<Expression>[new IntLiteral(1)]),
+    return buildError(new ShadowArguments(<Expression>[new IntLiteral(1)]),
         isGetter: true);
   }
 
   @override
   Expression buildNullAwareAssignment(
       Expression value, DartType type, int offset,
       {bool voidContext: false}) {
-    return buildError(new KernelArguments(<Expression>[value]), isSetter: true);
+    return buildError(new ShadowArguments(<Expression>[value]), isSetter: true);
   }
 
   @override
   Expression buildSimpleRead() =>
       buildError(new Arguments.empty(), isGetter: true);
 
   @override
   Expression makeInvalidRead() =>
       buildError(new Arguments.empty(), isGetter: true);
 
   @override
   Expression makeInvalidWrite(Expression value) {
-    return buildError(new KernelArguments(<Expression>[value]), isSetter: true);
+    return buildError(new ShadowArguments(<Expression>[value]), isSetter: true);
   }
 }
 
 class ThisAccessor extends FastaAccessor {
   final BuilderHelper helper;
 
   final Token token;
 
   final bool isInitializer;
 
   final bool isSuper;
 
   ThisAccessor(this.helper, this.token, this.isInitializer,
       {this.isSuper: false});
 
   String get plainNameForRead {
     return unsupported("${isSuper ? 'super' : 'this'}.plainNameForRead",
         offsetForToken(token), uri);
   }
 
   Expression buildSimpleRead() {
     if (!isSuper) {
-      return new KernelThisExpression();
+      return new ShadowThisExpression();
     } else {
       return helper.deprecated_buildCompileTimeError(
           "Can't use `super` as an expression.", offsetForToken(token));
     }
   }
 
   @override
   Initializer buildFieldInitializer(Map<String, int> initializedFields) {
     String keyword = isSuper ? "super" : "this";
     int offset = offsetForToken(token);
@@ skipping 10 matching lines @@
         helper.deprecated_addCompileTimeError(
             operatorOffset, "Expected '.'\nTry removing '?'.");
       }
       return buildConstructorInitializer(
           offsetForToken(send.token), send.name, send.arguments);
     }
     if (send is SendAccessor) {
       // Notice that 'this' or 'super' can't be null. So we can ignore the
       // value of [isNullAware].
       MethodInvocation result = helper.buildMethodInvocation(
-          new KernelThisExpression(),
+          new ShadowThisExpression(),
           send.name,
           send.arguments,
           offsetForToken(send.token));
       return isSuper ? helper.toSuperMethodInvocation(result) : result;
     } else {
       if (isSuper) {
         Member getter = helper.lookupSuperMember(send.name);
         Member setter = helper.lookupSuperMember(send.name, isSetter: true);
         return new SuperPropertyAccessor(
             helper, send.token, send.name, getter, setter);
       } else {
         return new ThisPropertyAccessor(
             helper, send.token, send.name, null, null);
       }
     }
   }
 
   doInvocation(int offset, Arguments arguments) {
     if (isInitializer) {
       return buildConstructorInitializer(offset, new Name(""), arguments);
     } else {
       return helper.buildMethodInvocation(
-          new KernelThisExpression(), callName, arguments, offset,
+          new ShadowThisExpression(), callName, arguments, offset,
           isImplicitCall: true);
     }
   }
 
   Initializer buildConstructorInitializer(
       int offset, Name name, Arguments arguments) {
     Constructor constructor = helper.lookupConstructor(name, isSuper: isSuper);
     if (constructor == null ||
         !helper.checkArguments(
             constructor.function, arguments, <TypeParameter>[])) {
@@ skipping 263 matching lines @@
       Procedure setter) {
     if (receiver is ThisExpression) {
       return new ThisIndexAccessor(helper, token, index, getter, setter);
     } else {
       return new IndexAccessor.internal(
           helper, token, receiver, index, getter, setter);
     }
   }
 
   @override
-  KernelComplexAssignment startComplexAssignment(Expression rhs) =>
-      new KernelIndexAssign(receiver, index, rhs);
+  ShadowComplexAssignment startComplexAssignment(Expression rhs) =>
+      new ShadowIndexAssign(receiver, index, rhs);
 }
 
 class PropertyAccessor extends kernel.PropertyAccessor with FastaAccessor {
   final BuilderHelper helper;
 
   PropertyAccessor.internal(this.helper, Token token, Expression receiver,
       Name name, Member getter, Member setter)
       : super.internal(helper, receiver, name, getter, setter, token);
 
   String get plainNameForRead => name.name;
@@ skipping 19 matching lines @@
     } else {
       return isNullAware
           ? new NullAwarePropertyAccessor(
               helper, token, receiver, name, getter, setter, null)
           : new PropertyAccessor.internal(
               helper, token, receiver, name, getter, setter);
     }
   }
 
   @override
-  KernelComplexAssignment startComplexAssignment(Expression rhs) =>
-      new KernelPropertyAssign(receiver, rhs);
+  ShadowComplexAssignment startComplexAssignment(Expression rhs) =>
+      new ShadowPropertyAssign(receiver, rhs);
 }
 
 class StaticAccessor extends kernel.StaticAccessor with FastaAccessor {
   StaticAccessor(
       BuilderHelper helper, Token token, Member readTarget, Member writeTarget)
       : super(helper, readTarget, writeTarget, token) {
     assert(readTarget != null || writeTarget != null);
   }
 
   factory StaticAccessor.fromBuilder(BuilderHelper helper, Builder builder,
@@ skipping 34 matching lines @@
           isImplicitCall: true);
     } else {
       return helper.buildStaticInvocation(readTarget, arguments)
         ..fileOffset = offset;
     }
   }
 
   toString() => "StaticAccessor()";
 
   @override
-  KernelComplexAssignment startComplexAssignment(Expression rhs) =>
-      new KernelStaticAssignment(rhs);
+  ShadowComplexAssignment startComplexAssignment(Expression rhs) =>
+      new ShadowStaticAssignment(rhs);
 }
 
 class SuperPropertyAccessor extends kernel.SuperPropertyAccessor
     with FastaAccessor {
   SuperPropertyAccessor(BuilderHelper helper, Token token, Name name,
       Member getter, Member setter)
       : super(helper, name, getter, setter, token);
 
   String get plainNameForRead => name.name;
 
@@ skipping 12 matching lines @@
     } else {
       // TODO(ahe): This could be something like "super.property(...)" where
       // property is a setter.
       return unhandled("${getter.runtimeType}", "doInvocation", offset, uri);
     }
   }
 
   toString() => "SuperPropertyAccessor()";
 
   @override
-  KernelComplexAssignment startComplexAssignment(Expression rhs) =>
-      new KernelPropertyAssign(null, rhs, isSuper: true);
+  ShadowComplexAssignment startComplexAssignment(Expression rhs) =>
+      new ShadowPropertyAssign(null, rhs, isSuper: true);
 }
 
 class ThisIndexAccessor extends kernel.ThisIndexAccessor with FastaAccessor {
   ThisIndexAccessor(BuilderHelper helper, Token token, Expression index,
       Procedure getter, Procedure setter)
       : super(helper, index, getter, setter, token);
 
   String get plainNameForRead => "[]";
 
   String get plainNameForWrite => "[]=";
 
   Expression doInvocation(int offset, Arguments arguments) {
     return helper.buildMethodInvocation(
         buildSimpleRead(), callName, arguments, offset,
         isImplicitCall: true);
   }
 
   toString() => "ThisIndexAccessor()";
 
   @override
-  KernelComplexAssignment startComplexAssignment(Expression rhs) =>
-      new KernelIndexAssign(null, index, rhs);
+  ShadowComplexAssignment startComplexAssignment(Expression rhs) =>
+      new ShadowIndexAssign(null, index, rhs);
 }
 
 class SuperIndexAccessor extends kernel.SuperIndexAccessor with FastaAccessor {
   SuperIndexAccessor(BuilderHelper helper, Token token, Expression index,
       Member getter, Member setter)
       : super(helper, index, getter, setter, token);
 
   String get plainNameForRead => "[]";
 
   String get plainNameForWrite => "[]=";
 
   Expression doInvocation(int offset, Arguments arguments) {
     return helper.buildMethodInvocation(
         buildSimpleRead(), callName, arguments, offset,
         isImplicitCall: true);
   }
 
   toString() => "SuperIndexAccessor()";
 
   @override
-  KernelComplexAssignment startComplexAssignment(Expression rhs) =>
-      new KernelIndexAssign(null, index, rhs, isSuper: true);
+  ShadowComplexAssignment startComplexAssignment(Expression rhs) =>
+      new ShadowIndexAssign(null, index, rhs, isSuper: true);
 }
 
 class ThisPropertyAccessor extends kernel.ThisPropertyAccessor
     with FastaAccessor {
   final BuilderHelper helper;
 
   ThisPropertyAccessor(
       this.helper, Token token, Name name, Member getter, Member setter)
       : super(helper, name, getter, setter, token);
 
   String get plainNameForRead => name.name;
 
   bool get isThisPropertyAccessor => true;
 
   Expression doInvocation(int offset, Arguments arguments) {
     Member interfaceTarget = getter;
     if (interfaceTarget is Field) {
       // TODO(ahe): In strong mode we should probably rewrite this to
       // `this.name.call(arguments)`.
       interfaceTarget = null;
     }
     return helper.buildMethodInvocation(
-        new KernelThisExpression(), name, arguments, offset);
+        new ShadowThisExpression(), name, arguments, offset);
   }
 
   toString() => "ThisPropertyAccessor()";
 
   @override
-  KernelComplexAssignment startComplexAssignment(Expression rhs) =>
-      new KernelPropertyAssign(null, rhs);
+  ShadowComplexAssignment startComplexAssignment(Expression rhs) =>
+      new ShadowPropertyAssign(null, rhs);
 }
 
 class NullAwarePropertyAccessor extends kernel.NullAwarePropertyAccessor
     with FastaAccessor {
   final BuilderHelper helper;
 
   NullAwarePropertyAccessor(this.helper, Token token, Expression receiver,
       Name name, Member getter, Member setter, DartType type)
       : super(helper, receiver, name, getter, setter, type, token);
 
   String get plainNameForRead => name.name;
 
   Expression doInvocation(int offset, Arguments arguments) {
     return unimplemented("doInvocation", offset, uri);
   }
 
   toString() => "NullAwarePropertyAccessor()";
 
   @override
-  KernelComplexAssignment startComplexAssignment(Expression rhs) =>
-      new KernelPropertyAssign(receiverExpression, rhs);
+  ShadowComplexAssignment startComplexAssignment(Expression rhs) =>
+      new ShadowPropertyAssign(receiverExpression, rhs);
 }
 
 int adjustForImplicitCall(String name, int offset) {
   // Normally the offset is at the start of the token, but in this case,
   // because we insert a '.call', we want it at the end instead.
   return offset + (name?.length ?? 0);
 }
 
 class VariableAccessor extends kernel.VariableAccessor with FastaAccessor {
   VariableAccessor(
       BuilderHelper helper, Token token, VariableDeclaration variable,
       [DartType promotedType])
       : super(helper, variable, promotedType, token);
 
   String get plainNameForRead => variable.name;
 
   Expression doInvocation(int offset, Arguments arguments) {
     return helper.buildMethodInvocation(buildSimpleRead(), callName, arguments,
         adjustForImplicitCall(plainNameForRead, offset),
         isImplicitCall: true);
   }
 
   toString() => "VariableAccessor()";
 
   @override
-  KernelComplexAssignment startComplexAssignment(Expression rhs) =>
-      new KernelVariableAssignment(rhs);
+  ShadowComplexAssignment startComplexAssignment(Expression rhs) =>
+      new ShadowVariableAssignment(rhs);
 }
 
 class ReadOnlyAccessor extends kernel.ReadOnlyAccessor with FastaAccessor {
   final String plainNameForRead;
 
   ReadOnlyAccessor(BuilderHelper helper, Expression expression,
       this.plainNameForRead, Token token)
       : super(helper, expression, token);
 
   Expression doInvocation(int offset, Arguments arguments) {
@@ skipping 27 matching lines @@
       if (declaration is KernelInvalidTypeBuilder) {
         KernelInvalidTypeBuilder declaration = this.declaration;
         helper.library.addWarning(
             declaration.message, declaration.charOffset, declaration.fileUri);
         helper.warning(declaration.message, offset);
         super.expression = new Throw(
             new StringLiteral(declaration.message.message)
               ..fileOffset = offsetForToken(token))
           ..fileOffset = offset;
       } else {
-        super.expression = new KernelTypeLiteral(
+        super.expression = new ShadowTypeLiteral(
             buildType(null, nonInstanceAccessIsError: true))
           ..fileOffset = offsetForToken(token);
       }
     }
     return super.expression;
   }
 
   Expression makeInvalidWrite(Expression value) {
     return buildThrowNoSuchMethodError(
         new NullLiteral()..fileOffset = offsetForToken(token),
@@ skipping 78 matching lines @@
     offset ??= offsetForToken(this.token);
     return helper.throwNoSuchMethodError(new NullLiteral()..fileOffset = offset,
         plainNameForRead, arguments, offset,
         isGetter: isGetter, isSetter: isSetter);
   }
 }
 
 bool isFieldOrGetter(Member member) {
   return member is Field || (member is Procedure && member.isGetter);
 }