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

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 'package:kernel/ast.dart'
     hide InvalidExpression, InvalidInitializer, InvalidStatement;
 
 import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
@@ skipping 256 matching lines @@
       var statement = statements[i];
       if (statement is List) {
         copy ??= new List<Statement>.from(statements.getRange(0, i));
         // TODO(sigmund): remove this assignment (issue #28651)
         Iterable subStatements = statement;
         copy.addAll(subStatements);
       } else if (copy != null) {
         copy.add(statement);
       }
     }
-    return new KernelBlock(copy ?? statements)
+    return new ShadowBlock(copy ?? statements)
       ..fileOffset = offsetForToken(beginToken);
   }
 
   Statement popStatementIfNotNull(Object value) {
     return value == null ? null : popStatement();
   }
 
   Statement popStatement() {
     var statement = pop();
     if (statement is List) {
@@ skipping 316 matching lines @@
       target.addAnnotation(annotation);
     }
     if (formals?.optional != null) {
       Iterator<FormalParameterBuilder> formalBuilders =
           builder.formals.skip(formals.required.length).iterator;
       for (VariableDeclaration parameter in formals.optional.formals) {
         bool hasMore = formalBuilders.moveNext();
         assert(hasMore);
         VariableDeclaration realParameter = formalBuilders.current.target;
         Expression initializer =
-            parameter.initializer ?? new KernelNullLiteral();
+            parameter.initializer ?? new ShadowNullLiteral();
         _typeInferrer.inferParameterInitializer(
             initializer, realParameter.type);
         realParameter.initializer = initializer..parent = realParameter;
       }
     }
     if (builder is KernelConstructorBuilder) {
       finishConstructor(builder, asyncModifier);
     } else if (builder is KernelProcedureBuilder) {
       builder.asyncModifier = asyncModifier;
     } else {
@@ skipping 53 matching lines @@
       /// >and no body is provided, then c implicitly has an empty body {}.
       /// We use an empty statement instead.
       constructor.function.body = new EmptyStatement();
       constructor.function.body.parent = constructor.function;
     }
   }
 
   @override
   void endExpressionStatement(Token token) {
     debugEvent("ExpressionStatement");
-    push(new KernelExpressionStatement(popForEffect()));
+    push(new ShadowExpressionStatement(popForEffect()));
   }
 
   @override
   void endArguments(int count, Token beginToken, Token endToken) {
     debugEvent("Arguments");
     List arguments = popList(count) ?? <Expression>[];
     int firstNamedArgumentIndex = arguments.length;
     for (int i = 0; i < arguments.length; i++) {
       var node = arguments[i];
       if (node is NamedExpression) {
@@ skipping 35 matching lines @@
                 "Duplicated named argument '${expression.name}'.",
                 expression.fileOffset);
           } else {
             seenNames[expression.name] = expression;
           }
         }
         if (hasProblem) {
           named = new List<NamedExpression>.from(seenNames.values);
         }
       }
-      push(new KernelArguments(positional, named: named)
+      push(new ShadowArguments(positional, named: named)
         ..fileOffset = beginToken.charOffset);
     } else {
-      push(new KernelArguments(arguments)..fileOffset = beginToken.charOffset);
+      push(new ShadowArguments(arguments)..fileOffset = beginToken.charOffset);
     }
   }
 
   @override
   void handleParenthesizedExpression(Token token) {
     debugEvent("ParenthesizedExpression");
     push(new ParenthesizedExpression(
         this, popForValue(), closeBraceTokenFor(token)));
   }
 
   @override
   void handleSend(Token beginToken, Token endToken) {
     debugEvent("Send");
     Arguments arguments = pop();
     List<DartType> typeArguments = pop();
     Object receiver = pop();
     if (arguments != null && typeArguments != null) {
       assert(arguments.types.isEmpty);
-      KernelArguments.setExplicitArgumentTypes(arguments, typeArguments);
+      ShadowArguments.setExplicitArgumentTypes(arguments, typeArguments);
     } else {
       assert(typeArguments == null);
     }
     if (receiver is Identifier) {
       Name name = new Name(receiver.name, library.library);
       if (arguments == null) {
         push(new IncompletePropertyAccessor(this, beginToken, name));
       } else {
         push(new SendAccessor(this, beginToken, name, arguments));
       }
@@ skipping 12 matching lines @@
       return buildMethodInvocation(
           toValue(receiver), callName, arguments, charOffset,
           isImplicitCall: true);
     }
   }
 
   @override
   void beginCascade(Token token) {
     debugEvent("beginCascade");
     Expression expression = popForValue();
-    if (expression is KernelCascadeExpression) {
+    if (expression is ShadowCascadeExpression) {
       push(expression);
       push(new VariableAccessor(this, token, expression.variable));
       expression.extend();
     } else {
-      VariableDeclaration variable = new KernelVariableDeclaration.forValue(
+      VariableDeclaration variable = new ShadowVariableDeclaration.forValue(
           expression, functionNestingLevel);
-      push(new KernelCascadeExpression(variable));
+      push(new ShadowCascadeExpression(variable));
       push(new VariableAccessor(this, token, variable));
     }
   }
 
   @override
   void endCascade() {
     debugEvent("endCascade");
     Expression expression = popForEffect();
-    KernelCascadeExpression cascadeReceiver = pop();
+    ShadowCascadeExpression cascadeReceiver = pop();
     cascadeReceiver.finalize(expression);
     push(cascadeReceiver);
   }
 
   @override
   void beginCaseExpression(Token caseKeyword) {
     debugEvent("beginCaseExpression");
     super.push(constantExpressionRequired);
     constantExpressionRequired = true;
   }
@@ skipping 16 matching lines @@
       return doLogicalExpression(token);
     }
     if (optional("??", token)) return doIfNull(token);
     if (optional("?.", token)) return doIfNotNull(token);
     Expression argument = popForValue();
     var receiver = pop();
     bool isSuper = false;
     if (receiver is ThisAccessor && receiver.isSuper) {
       ThisAccessor thisAccessorReceiver = receiver;
       isSuper = true;
-      receiver = new KernelThisExpression()
+      receiver = new ShadowThisExpression()
         ..fileOffset = offsetForToken(thisAccessorReceiver.token);
     }
     push(buildBinaryOperator(toValue(receiver), token, argument, isSuper));
   }
 
   Expression buildBinaryOperator(
       Expression a, Token token, Expression b, bool isSuper) {
     bool negate = false;
     String operator = token.stringValue;
     if (identical("!=", operator)) {
       operator = "==";
       negate = true;
     }
     if (!isBinaryOperator(operator) && !isMinusOperator(operator)) {
       return deprecated_buildCompileTimeError(
           "Not an operator: '$operator'.", token.charOffset);
     } else {
       Expression result =
           makeBinary(a, new Name(operator), null, b, offset: token.charOffset);
       if (isSuper) {
         result = toSuperMethodInvocation(result);
       }
-      return negate ? new KernelNot(result) : result;
+      return negate ? new ShadowNot(result) : result;
     }
   }
 
   void doLogicalExpression(Token token) {
     Expression argument = popForValue();
     Expression receiver = popForValue();
-    push(new KernelLogicalExpression(receiver, token.stringValue, argument));
+    push(new ShadowLogicalExpression(receiver, token.stringValue, argument));
   }
 
   /// Handle `a ?? b`.
   void doIfNull(Token token) {
     Expression b = popForValue();
     Expression a = popForValue();
     VariableDeclaration variable = new VariableDeclaration.forValue(a);
-    push(new KernelIfNullExpression(
+    push(new ShadowIfNullExpression(
         variable,
         new ConditionalExpression(
             buildIsNull(new VariableGet(variable), offsetForToken(token)),
             b,
             new VariableGet(variable),
             null)));
   }
 
   /// Handle `a?.b(...)`.
   void doIfNotNull(Token token) {
@@ skipping 16 matching lines @@
         warnUnresolvedSuperMethod(node.name, node.fileOffset);
       } else if (!areArgumentsCompatible(target.function, node.arguments)) {
         target = null;
         warning(
             fasta.templateSuperclassMethodArgumentMismatch
                 .withArguments(node.name.name),
             node.fileOffset);
       }
       Expression result;
       if (target != null) {
-        result = new KernelDirectMethodInvocation(
-            new KernelThisExpression()..fileOffset = node.fileOffset,
+        result = new ShadowDirectMethodInvocation(
+            new ShadowThisExpression()..fileOffset = node.fileOffset,
             target,
             node.arguments);
       }
       // TODO(ahe): Use [DirectMethodInvocation] when possible, that is,
       // make the next line conditional:
       result =
-          new KernelSuperMethodInvocation(node.name, node.arguments, target);
+          new ShadowSuperMethodInvocation(node.name, node.arguments, target);
       return result..fileOffset = node.fileOffset;
     }
 
-    Expression receiver = new KernelDirectPropertyGet(
-        new KernelThisExpression()..fileOffset = node.fileOffset, target)
+    Expression receiver = new ShadowDirectPropertyGet(
+        new ShadowThisExpression()..fileOffset = node.fileOffset, target)
       ..fileOffset = node.fileOffset;
     // TODO(ahe): Use [DirectPropertyGet] when possible, that is, make the next
     // line conditional:
-    receiver = new KernelSuperPropertyGet(node.name, target)
+    receiver = new ShadowSuperPropertyGet(node.name, target)
       ..fileOffset = node.fileOffset;
     return buildMethodInvocation(
         receiver, callName, node.arguments, node.arguments.fileOffset,
         isImplicitCall: true);
   }
 
   bool areArgumentsCompatible(FunctionNode function, Arguments arguments) {
     // TODO(ahe): Implement this.
     return true;
   }
@@ skipping 21 matching lines @@
       return buildCompileTimeError(message, charOffset);
     } else {
       Expression error = library.loader.instantiateNoSuchMethodError(
           receiver, name, arguments, charOffset,
           isMethod: !isGetter && !isSetter,
           isGetter: isGetter,
           isSetter: isSetter,
           isStatic: isStatic,
           isTopLevel: !isStatic && !isSuper);
       warning(message, charOffset);
-      return new KernelSyntheticExpression(new Throw(error));
+      return new ShadowSyntheticExpression(new Throw(error));
     }
   }
 
   @override
   void warnUnresolvedSuperGet(Name name, int charOffset) {
     warning(fasta.templateSuperclassHasNoGetter.withArguments(name.name),
         charOffset);
   }
 
   @override
@@ skipping 89 matching lines @@
         return deprecated_buildCompileTimeError(message, offset);
       } else if (!isQualified && isInstanceContext) {
         assert(builder == null);
         if (constantExpressionRequired || member.isField) {
           return new UnresolvedAccessor(this, n, token);
         }
         return new ThisPropertyAccessor(this, token, n, null, null);
       } else if (ignoreMainInGetMainClosure &&
           name == "main" &&
           member?.name == "_getMainClosure") {
-        return new KernelNullLiteral()..fileOffset = offsetForToken(token);
+        return new ShadowNullLiteral()..fileOffset = offsetForToken(token);
       } else {
         return new UnresolvedAccessor(this, n, token);
       }
     } else if (builder.isTypeDeclaration) {
       if (constantExpressionRequired &&
           builder.isTypeVariable &&
           !member.isConstructor) {
         deprecated_addCompileTimeError(
             offsetForToken(token), "Not a constant expression.");
       }
       return new TypeDeclarationAccessor(this, builder, name, token);
     } else if (builder.isLocal) {
       if (constantExpressionRequired &&
           !builder.isConst &&
           !member.isConstructor) {
         deprecated_addCompileTimeError(
             offsetForToken(token), "Not a constant expression.");
       }
       // An initializing formal parameter might be final without its
       // VariableDeclaration being final. See
       // [ProcedureBuilder.computeFormalParameterInitializerScope]. If that
       // wasn't the case, we could always use VariableAccessor.
       if (builder.isFinal) {
         var fact =
             typePromoter.getFactForAccess(builder.target, functionNestingLevel);
         var scope = typePromoter.currentScope;
         return new ReadOnlyAccessor(
             this,
-            new KernelVariableGet(builder.target, fact, scope)
+            new ShadowVariableGet(builder.target, fact, scope)
               ..fileOffset = offsetForToken(token),
             name,
             token);
       } else {
         return new VariableAccessor(this, token, builder.target);
       }
     } else if (builder.isInstanceMember) {
       if (constantExpressionRequired &&
           !inInitializer &&
           // TODO(ahe): This is a hack because Fasta sets up the scope
@@ skipping 64 matching lines @@
     debugEvent("StringPart");
     push(token);
   }
 
   @override
   void endLiteralString(int interpolationCount, Token endToken) {
     debugEvent("endLiteralString");
     if (interpolationCount == 0) {
       Token token = pop();
       String value = unescapeString(token.lexeme);
-      push(new KernelStringLiteral(value)..fileOffset = offsetForToken(token));
+      push(new ShadowStringLiteral(value)..fileOffset = offsetForToken(token));
     } else {
       List parts = popList(1 + interpolationCount * 2);
       Token first = parts.first;
       Token last = parts.last;
       Quote quote = analyzeQuote(first.lexeme);
       List<Expression> expressions = <Expression>[];
       // Contains more than just \' or \".
       if (first.lexeme.length > 1) {
         String value = unescapeFirstStringPart(first.lexeme, quote);
         expressions.add(
-            new KernelStringLiteral(value)..fileOffset = offsetForToken(first));
+            new ShadowStringLiteral(value)..fileOffset = offsetForToken(first));
       }
       for (int i = 1; i < parts.length - 1; i++) {
         var part = parts[i];
         if (part is Token) {
           if (part.lexeme.length != 0) {
             String value = unescape(part.lexeme, quote);
-            expressions.add(new KernelStringLiteral(value)
+            expressions.add(new ShadowStringLiteral(value)
               ..fileOffset = offsetForToken(part));
           }
         } else {
           expressions.add(toValue(part));
         }
       }
       // Contains more than just \' or \".
       if (last.lexeme.length > 1) {
         String value = unescapeLastStringPart(last.lexeme, quote);
         expressions.add(
-            new KernelStringLiteral(value)..fileOffset = offsetForToken(last));
+            new ShadowStringLiteral(value)..fileOffset = offsetForToken(last));
       }
-      push(new KernelStringConcatenation(expressions)
+      push(new ShadowStringConcatenation(expressions)
         ..fileOffset = offsetForToken(endToken));
     }
   }
 
   @override
   void handleScript(Token token) {
     debugEvent("Script");
   }
 
   @override
   void handleStringJuxtaposition(int literalCount) {
     debugEvent("StringJuxtaposition");
     List<Expression> parts = popListForValue(literalCount);
     List<Expression> expressions;
     // Flatten string juxtapositions of string interpolation.
     for (int i = 0; i < parts.length; i++) {
       Expression part = parts[i];
       if (part is StringConcatenation) {
         if (expressions == null) {
           expressions = parts.sublist(0, i);
         }
         expressions.addAll(part.expressions);
       } else {
         if (expressions != null) {
           expressions.add(part);
         }
       }
     }
-    push(new KernelStringConcatenation(expressions ?? parts));
+    push(new ShadowStringConcatenation(expressions ?? parts));
   }
 
   @override
   void handleLiteralInt(Token token) {
     debugEvent("LiteralInt");
     int value = int.parse(token.lexeme, onError: (_) => null);
     if (value == null) {
       push(buildCompileTimeError(
           fasta.templateIntegerLiteralIsOutOfRange.withArguments(token),
           token.charOffset));
     } else {
-      push(new KernelIntLiteral(value)..fileOffset = offsetForToken(token));
+      push(new ShadowIntLiteral(value)..fileOffset = offsetForToken(token));
     }
   }
 
   @override
   void handleEmptyFunctionBody(Token semicolon) {
     debugEvent("ExpressionFunctionBody");
     endBlockFunctionBody(0, null, semicolon);
   }
 
   @override
   void handleExpressionFunctionBody(Token arrowToken, Token endToken) {
     debugEvent("ExpressionFunctionBody");
     endReturnStatement(true, arrowToken.next, endToken);
   }
 
   @override
   void endReturnStatement(
       bool hasExpression, Token beginToken, Token endToken) {
     debugEvent("ReturnStatement");
     Expression expression = hasExpression ? popForValue() : null;
     if (expression != null && inConstructor) {
       push(deprecated_buildCompileTimeErrorStatement(
           "Can't return from a constructor.", beginToken.charOffset));
     } else {
-      push(new KernelReturnStatement(expression)
+      push(new ShadowReturnStatement(expression)
         ..fileOffset = beginToken.charOffset);
     }
   }
 
   @override
   void beginThenStatement(Token token) {
     Expression condition = popForValue();
     typePromoter.enterThen(condition);
     push(condition);
     super.beginThenStatement(token);
   }
 
   @override
   void endThenStatement(Token token) {
     typePromoter.enterElse();
     super.endThenStatement(token);
   }
 
   @override
   void endIfStatement(Token ifToken, Token elseToken) {
     Statement elsePart = popStatementIfNotNull(elseToken);
     Statement thenPart = popStatement();
     Expression condition = popForValue();
     typePromoter.exitConditional();
-    push(new KernelIfStatement(condition, thenPart, elsePart));
+    push(new ShadowIfStatement(condition, thenPart, elsePart));
   }
 
   @override
   void endVariableInitializer(Token assignmentOperator) {
     debugEvent("VariableInitializer");
     assert(assignmentOperator.stringValue == "=");
     pushNewLocalVariable(popForValue(), equalsToken: assignmentOperator);
   }
 
   @override
@@ skipping 16 matching lines @@
     }
     pushNewLocalVariable(initializer);
   }
 
   void pushNewLocalVariable(Expression initializer, {Token equalsToken}) {
     Identifier identifier = pop();
     assert(currentLocalVariableModifiers != -1);
     bool isConst = (currentLocalVariableModifiers & constMask) != 0;
     bool isFinal = (currentLocalVariableModifiers & finalMask) != 0;
     assert(isConst == constantExpressionRequired);
-    push(new KernelVariableDeclaration(identifier.name, functionNestingLevel,
+    push(new ShadowVariableDeclaration(identifier.name, functionNestingLevel,
         initializer: initializer,
         type: currentLocalVariableType,
         isFinal: isFinal,
         isConst: isConst)
       ..fileOffset = offsetForToken(identifier.token)
       ..fileEqualsOffset = offsetForToken(equalsToken));
   }
 
   @override
   void endFieldInitializer(Token assignmentOperator, Token token) {
     debugEvent("FieldInitializer");
     assert(assignmentOperator.stringValue == "=");
     push(popForValue());
   }
 
   @override
   void handleNoFieldInitializer(Token token) {
     debugEvent("NoFieldInitializer");
     if (constantExpressionRequired) {
       // Creating a null value to prevent the Dart VM from crashing.
-      push(new KernelNullLiteral()..fileOffset = offsetForToken(token));
+      push(new ShadowNullLiteral()..fileOffset = offsetForToken(token));
     } else {
       push(NullValue.FieldInitializer);
     }
   }
 
   @override
   void endInitializedIdentifier(Token nameToken) {
     // TODO(ahe): Use [InitializedIdentifier] here?
     debugEvent("InitializedIdentifier");
     VariableDeclaration variable = pop();
@@ skipping 93 matching lines @@
     }
     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.
     } else if (variableOrExpression is Expression) {
-      begin = new KernelExpressionStatement(variableOrExpression);
+      begin = new ShadowExpressionStatement(variableOrExpression);
     } else {
       return unhandled("${variableOrExpression.runtimeType}", "endForStatement",
           forKeyword.charOffset, uri);
     }
     exitLocalScope();
     JumpTarget continueTarget = exitContinueTarget();
     JumpTarget breakTarget = exitBreakTarget();
     if (continueTarget.hasUsers) {
-      body = new KernelLabeledStatement(body);
+      body = new ShadowLabeledStatement(body);
       continueTarget.resolveContinues(body);
     }
     Statement result =
-        new KernelForStatement(variables, condition, updates, body)
+        new ShadowForStatement(variables, condition, updates, body)
           ..fileOffset = forKeyword.charOffset;
     if (begin != null) {
-      result = new KernelBlock(<Statement>[begin, result]);
+      result = new ShadowBlock(<Statement>[begin, result]);
     }
     if (breakTarget.hasUsers) {
-      result = new KernelLabeledStatement(result);
+      result = new ShadowLabeledStatement(result);
       breakTarget.resolveBreaks(result);
     }
     exitLoopOrSwitch(result);
   }
 
   @override
   void endAwaitExpression(Token keyword, Token endToken) {
     debugEvent("AwaitExpression");
-    push(new KernelAwaitExpression(popForValue())
+    push(new ShadowAwaitExpression(popForValue())
       ..fileOffset = offsetForToken(keyword));
   }
 
   @override
   void handleAsyncModifier(Token asyncToken, Token starToken) {
     debugEvent("AsyncModifier");
     push(asyncMarkerFromTokens(asyncToken, starToken));
   }
 
   @override
   void handleLiteralList(
       int count, Token beginToken, Token constKeyword, Token endToken) {
     debugEvent("LiteralList");
     List<Expression> expressions = popListForValue(count);
     List<DartType> typeArguments = pop();
     DartType typeArgument;
     if (typeArguments != null) {
       typeArgument = typeArguments.first;
       if (typeArguments.length > 1) {
         typeArgument = null;
         warningNotError(fasta.messageListLiteralTooManyTypeArguments,
             beginToken.charOffset);
       }
     }
-    push(new KernelListLiteral(expressions,
+    push(new ShadowListLiteral(expressions,
         typeArgument: typeArgument, isConst: constKeyword != null)
       ..fileOffset = offsetForToken(constKeyword ?? beginToken));
   }
 
   @override
   void handleLiteralBool(Token token) {
     debugEvent("LiteralBool");
     bool value = optional("true", token);
     assert(value || optional("false", token));
-    push(new KernelBoolLiteral(value)..fileOffset = offsetForToken(token));
+    push(new ShadowBoolLiteral(value)..fileOffset = offsetForToken(token));
   }
 
   @override
   void handleLiteralDouble(Token token) {
     debugEvent("LiteralDouble");
-    push(new KernelDoubleLiteral(double.parse(token.lexeme))
+    push(new ShadowDoubleLiteral(double.parse(token.lexeme))
       ..fileOffset = offsetForToken(token));
   }
 
   @override
   void handleLiteralNull(Token token) {
     debugEvent("LiteralNull");
-    push(new KernelNullLiteral()..fileOffset = offsetForToken(token));
+    push(new ShadowNullLiteral()..fileOffset = offsetForToken(token));
   }
 
   @override
   void handleLiteralMap(
       int count, Token beginToken, Token constKeyword, Token endToken) {
     debugEvent("LiteralMap");
     List<MapEntry> entries = popList(count) ?? <MapEntry>[];
     List<DartType> typeArguments = pop();
     DartType keyType;
     DartType valueType;
     if (typeArguments != null) {
       if (typeArguments.length != 2) {
         keyType = null;
         valueType = null;
         warningNotError(fasta.messageListLiteralTypeArgumentMismatch,
             beginToken.charOffset);
       } else {
         keyType = typeArguments[0];
         valueType = typeArguments[1];
       }
     }
-    push(new KernelMapLiteral(entries,
+    push(new ShadowMapLiteral(entries,
         keyType: keyType, valueType: valueType, isConst: constKeyword != null)
       ..fileOffset = constKeyword?.charOffset ?? offsetForToken(beginToken));
   }
 
   @override
   void endLiteralMapEntry(Token colon, Token endToken) {
     debugEvent("LiteralMapEntry");
     Expression value = popForValue();
     Expression key = popForValue();
     push(new MapEntry(key, value));
@@ skipping 16 matching lines @@
     if (identifierCount == 1) {
       value = symbolPartToString(pop());
     } else {
       List parts = popList(identifierCount);
       value = symbolPartToString(parts.first);
       for (int i = 1; i < parts.length; i++) {
         value += ".${symbolPartToString(parts[i])}";
       }
     }
     push(
-        new KernelSymbolLiteral(value)..fileOffset = offsetForToken(hashToken));
+        new ShadowSymbolLiteral(value)..fileOffset = offsetForToken(hashToken));
   }
 
   DartType kernelTypeFromString(
       String name, List<DartType> arguments, int charOffset) {
     Builder builder = scope.lookup(name, charOffset, uri);
     if (builder == null) {
       warning(fasta.templateTypeNotFound.withArguments(name), charOffset);
       return const InvalidType();
     } else {
       return kernelTypeFromBuilder(builder, arguments, charOffset);
@@ skipping 121 matching lines @@
 
   @override
   void handleAsOperator(Token operator, Token endToken) {
     debugEvent("AsOperator");
     DartType type = pop();
     Expression expression = popForValue();
     if (constantExpressionRequired) {
       push(deprecated_buildCompileTimeError(
           "Not a constant expression.", operator.charOffset));
     } else {
-      push(new KernelAsExpression(expression, type)
+      push(new ShadowAsExpression(expression, type)
         ..fileOffset = offsetForToken(operator));
     }
   }
 
   @override
   void handleIsOperator(Token operator, Token not, Token endToken) {
     debugEvent("IsOperator");
     DartType type = pop();
     Expression operand = popForValue();
     bool isInverted = not != null;
     var offset = offsetForToken(operator);
     Expression isExpression = isInverted
-        ? new KernelIsNotExpression(operand, type, offset)
-        : new KernelIsExpression(operand, type)
+        ? new ShadowIsNotExpression(operand, type, offset)
+        : new ShadowIsExpression(operand, type)
       ..fileOffset = offset;
     if (operand is VariableGet) {
       typePromoter.handleIsCheck(isExpression, isInverted, operand.variable,
           type, functionNestingLevel);
     }
     if (constantExpressionRequired) {
       push(deprecated_buildCompileTimeError(
           "Not a constant expression.", operator.charOffset));
     } else {
       push(isExpression);
     }
   }
 
   @override
   void handleConditionalExpression(Token question, Token colon) {
     debugEvent("ConditionalExpression");
     Expression elseExpression = popForValue();
     Expression thenExpression = popForValue();
     Expression condition = popForValue();
-    push(new KernelConditionalExpression(
+    push(new ShadowConditionalExpression(
         condition, thenExpression, elseExpression));
   }
 
   @override
   void handleThrowExpression(Token throwToken, Token endToken) {
     debugEvent("ThrowExpression");
     Expression expression = popForValue();
     if (constantExpressionRequired) {
       push(deprecated_buildCompileTimeError(
           "Not a constant expression.", throwToken.charOffset));
     } else {
       push(
-          new KernelThrow(expression)..fileOffset = offsetForToken(throwToken));
+          new ShadowThrow(expression)..fileOffset = offsetForToken(throwToken));
     }
   }
 
   @override
   void endFormalParameter(Token thisKeyword, Token nameToken,
       FormalParameterKind kind, MemberKind memberKind) {
     debugEvent("FormalParameter");
     if (thisKeyword != null) {
       if (!inConstructor) {
         deprecated_addCompileTimeError(thisKeyword.charOffset,
@@ skipping 20 matching lines @@
         internalProblem(
             fasta.templateInternalProblemNotFoundIn
                 .withArguments(name.name, "formals"),
             member.charOffset,
             member.fileUri);
       } else {
         variable = formal.build(library);
         variable.initializer = name.initializer;
       }
     } else {
-      variable = new KernelVariableDeclaration(name?.name, functionNestingLevel,
+      variable = new ShadowVariableDeclaration(name?.name, functionNestingLevel,
           type: type,
           initializer: name?.initializer,
           isFinal: isFinal,
           isConst: isConst);
       if (name != null) {
         // TODO(ahe): Need an offset when name is null.
         variable.fileOffset = offsetForToken(name.token);
       }
     }
     push(variable);
@@ skipping 120 matching lines @@
     push(new Catch(exception, body, guard: type, stackTrace: stackTrace));
   }
 
   @override
   void endTryStatement(int catchCount, Token tryKeyword, Token finallyKeyword) {
     Statement finallyBlock = popStatementIfNotNull(finallyKeyword);
     List<Catch> catches = popList(catchCount);
     Statement tryBlock = popStatement();
     if (compileTimeErrorInTry == null) {
       if (catches != null) {
-        tryBlock = new KernelTryCatch(tryBlock, catches);
+        tryBlock = new ShadowTryCatch(tryBlock, catches);
       }
       if (finallyBlock != null) {
-        tryBlock = new KernelTryFinally(tryBlock, finallyBlock);
+        tryBlock = new ShadowTryFinally(tryBlock, finallyBlock);
       }
       push(tryBlock);
     } else {
       push(compileTimeErrorInTry);
       compileTimeErrorInTry = null;
     }
   }
 
   @override
   void handleNoExpression(Token token) {
@@ skipping 15 matching lines @@
           this, openSquareBracket, toValue(receiver), index, null, null));
     }
   }
 
   @override
   void handleUnaryPrefixExpression(Token token) {
     debugEvent("UnaryPrefixExpression");
     var receiver = pop();
     if (optional("!", token)) {
       push(
-          new KernelNot(toValue(receiver))..fileOffset = offsetForToken(token));
+          new ShadowNot(toValue(receiver))..fileOffset = offsetForToken(token));
     } else {
       String operator = token.stringValue;
       if (optional("-", token)) {
         operator = "unary-";
       }
       if (receiver is ThisAccessor && receiver.isSuper) {
         push(toSuperMethodInvocation(buildMethodInvocation(
-            new KernelThisExpression()
+            new ShadowThisExpression()
               ..fileOffset = offsetForToken(receiver.token),
             new Name(operator),
             new Arguments.empty(),
             token.charOffset)));
       } else {
         push(buildMethodInvocation(toValue(receiver), new Name(operator),
             new Arguments.empty(), token.charOffset,
             // This *could* be a constant expression, we can't know without
             // evaluating [receiver].
             isConstantExpression: true));
@@ skipping 115 matching lines @@
     }
     if (!checkArguments(target.function, arguments, typeParameters)) {
       return throwNoSuchMethodError(new NullLiteral()..fileOffset = charOffset,
           target.name.name, arguments, charOffset);
     }
     if (target is Constructor) {
       if (isConst && !target.isConst) {
         return deprecated_buildCompileTimeError(
             "Not a const constructor.", charOffset);
       }
-      return new KernelConstructorInvocation(target, initialTarget, arguments,
+      return new ShadowConstructorInvocation(target, initialTarget, arguments,
           isConst: isConst)
         ..fileOffset = charOffset;
     } else {
       Procedure procedure = target;
       if (isConst && !procedure.isConst) {
         return deprecated_buildCompileTimeError(
             "Not a const factory.", charOffset);
       } else if (procedure.isFactory) {
-        return new KernelFactoryConstructorInvocation(
+        return new ShadowFactoryConstructorInvocation(
             target, initialTarget, arguments,
             isConst: isConst)
           ..fileOffset = charOffset;
       } else {
-        return new KernelStaticInvocation(target, arguments, isConst: isConst)
+        return new ShadowStaticInvocation(target, arguments, isConst: isConst)
           ..fileOffset = charOffset;
       }
     }
   }
 
   @override
   bool checkArguments(FunctionNode function, Arguments arguments,
       List<TypeParameter> typeParameters) {
     if (arguments.positional.length < function.requiredParameterCount ||
         arguments.positional.length > function.positionalParameters.length) {
@@ skipping 55 matching lines @@
     debugEvent("endConstLiteral");
     var literal = pop();
     constantExpressionRequired = pop();
     push(literal);
   }
 
   @override
   void endNewExpression(Token token) {
     debugEvent("NewExpression");
     Token nameToken = token.next;
-    KernelArguments arguments = pop();
+    ShadowArguments arguments = pop();
     String name = pop();
     List<DartType> typeArguments = pop();
     var type = pop();
     if (type is TypeDeclarationAccessor) {
       TypeDeclarationAccessor accessor = type;
       type = accessor.declaration;
     }
     bool savedConstantExpressionRequired = pop();
     () {
       if (arguments == null) {
         push(deprecated_buildCompileTimeError(
             "No arguments.", nameToken.charOffset));
         return;
       }
 
       if (typeArguments != null) {
         assert(arguments.types.isEmpty);
-        KernelArguments.setExplicitArgumentTypes(arguments, typeArguments);
+        ShadowArguments.setExplicitArgumentTypes(arguments, typeArguments);
       }
 
       String errorName;
       if (type is ClassBuilder) {
         if (type is EnumBuilder) {
           push(deprecated_buildCompileTimeError(
               "An enum class can't be instantiated.", nameToken.charOffset));
           return;
         }
         Builder b =
             type.findConstructorOrFactory(name, token.charOffset, uri, library);
         Member target;
         Member initialTarget;
         if (b == null) {
           // Not found. Reported below.
         } else if (b.isConstructor) {
           initialTarget = b.target;
           if (type.isAbstract) {
-            push(new KernelSyntheticExpression(evaluateArgumentsBefore(
+            push(new ShadowSyntheticExpression(evaluateArgumentsBefore(
                 arguments,
                 buildAbstractClassInstantiationError(
                     type.name, nameToken.charOffset))));
             return;
           } else {
             target = initialTarget;
           }
         } else if (b.isFactory) {
           initialTarget = b.target;
           target = getRedirectionTarget(initialTarget);
@@ skipping 76 matching lines @@
     Expression value = popForValue();
     Identifier identifier = pop();
     push(new NamedExpression(identifier.name, value)
       ..fileOffset = offsetForToken(identifier.token));
   }
 
   @override
   void endFunctionName(Token beginToken, Token token) {
     debugEvent("FunctionName");
     Identifier name = pop();
-    VariableDeclaration variable = new KernelVariableDeclaration(
+    VariableDeclaration variable = new ShadowVariableDeclaration(
         name.name, functionNestingLevel,
         isFinal: true, isLocalFunction: true)
       ..fileOffset = offsetForToken(name.token);
     if (scope.local[variable.name] != null) {
       deprecated_addCompileTimeError(offsetForToken(name.token),
           "'${variable.name}' already declared in this scope.");
     }
-    push(new KernelFunctionDeclaration(
+    push(new ShadowFunctionDeclaration(
         variable,
         // The function node is created later.
         null)
       ..fileOffset = beginToken.charOffset);
     declareVariable(variable, scope.parent);
   }
 
   void enterFunction() {
     debugEvent("enterFunction");
     enterFunctionTypeScope();
@@ skipping 51 matching lines @@
     List<TypeParameter> typeParameters = typeVariableBuildersToKernel(pop());
     FunctionNode function = formals.addToFunction(new FunctionNode(body,
         typeParameters: typeParameters,
         asyncMarker: asyncModifier,
         returnType: returnType)
       ..fileOffset = formals.charOffset
       ..fileEndOffset = token.charOffset);
 
     if (declaration is FunctionDeclaration) {
       VariableDeclaration variable = declaration.variable;
-      KernelFunctionDeclaration.setHasImplicitReturnType(
+      ShadowFunctionDeclaration.setHasImplicitReturnType(
           declaration, hasImplicitReturnType);
 
       variable.type = function.functionType;
       if (isFunctionExpression) {
-        variable.initializer = new KernelFunctionExpression(function)
+        variable.initializer = new ShadowFunctionExpression(function)
           ..parent = variable
           ..fileOffset = formals.charOffset;
         exitLocalScope();
-        push(new KernelNamedFunctionExpression(variable));
+        push(new ShadowNamedFunctionExpression(variable));
       } else {
         declaration.function = function;
         function.parent = declaration;
         push(declaration);
       }
     } else if (declaration is ExpressionStatement) {
       // If [declaration] isn't a [FunctionDeclaration], it must be because
       // there was a compile-time error.
       assert(library.hasCompileTimeErrors);
 
@@ skipping 32 matching lines @@
     exitFunction();
     List<TypeParameter> typeParameters = typeVariableBuildersToKernel(pop());
     FunctionNode function = formals.addToFunction(new FunctionNode(body,
         typeParameters: typeParameters, asyncMarker: asyncModifier)
       ..fileOffset = beginToken.charOffset
       ..fileEndOffset = token.charOffset);
     if (constantExpressionRequired) {
       push(deprecated_buildCompileTimeError(
           "Not a constant expression.", formals.charOffset));
     } else {
-      push(new KernelFunctionExpression(function)
+      push(new ShadowFunctionExpression(function)
         ..fileOffset = offsetForToken(beginToken));
     }
   }
 
   @override
   void endDoWhileStatement(
       Token doKeyword, Token whileKeyword, Token endToken) {
     debugEvent("DoWhileStatement");
     Expression condition = popForValue();
     Statement body = popStatement();
     JumpTarget continueTarget = exitContinueTarget();
     JumpTarget breakTarget = exitBreakTarget();
     if (continueTarget.hasUsers) {
-      body = new KernelLabeledStatement(body);
+      body = new ShadowLabeledStatement(body);
       continueTarget.resolveContinues(body);
     }
-    Statement result = new KernelDoStatement(body, condition)
+    Statement result = new ShadowDoStatement(body, condition)
       ..fileOffset = doKeyword.charOffset;
     if (breakTarget.hasUsers) {
-      result = new KernelLabeledStatement(result);
+      result = new ShadowLabeledStatement(result);
       breakTarget.resolveBreaks(result);
     }
     exitLoopOrSwitch(result);
   }
 
   @override
   void beginForInExpression(Token token) {
     enterLocalScope(null, scope.parent);
   }
 
   @override
   void endForInExpression(Token token) {
     debugEvent("ForInExpression");
     Expression expression = popForValue();
     exitLocalScope();
     push(expression ?? NullValue.Expression);
   }
 
   @override
   void endForIn(Token awaitToken, Token forToken, Token leftParenthesis,
       Token inKeyword, Token rightParenthesis, Token endToken) {
     debugEvent("ForIn");
     Statement body = popStatement();
     Expression expression = popForValue();
     var lvalue = pop();
     exitLocalScope();
     JumpTarget continueTarget = exitContinueTarget();
     JumpTarget breakTarget = exitBreakTarget();
     if (continueTarget.hasUsers) {
-      body = new KernelLabeledStatement(body);
+      body = new ShadowLabeledStatement(body);
       continueTarget.resolveContinues(body);
     }
     VariableDeclaration variable;
     bool declaresVariable = false;
     if (lvalue is VariableDeclaration) {
       declaresVariable = true;
       variable = lvalue;
       if (variable.isConst) {
         deprecated_addCompileTimeError(
             variable.fileOffset, "A for-in loop-variable can't be 'const'.");
       }
     } 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;
       ///     }
       variable = new VariableDeclaration.forValue(null);
       body = combineStatements(
-          new KernelSyntheticStatement(new ExpressionStatement(lvalue
+          new ShadowSyntheticStatement(new ExpressionStatement(lvalue
               .buildAssignment(new VariableGet(variable), voidContext: true))),
           body);
     } else {
       variable = new VariableDeclaration.forValue(
           deprecated_buildCompileTimeError("Expected lvalue, but got ${lvalue}",
               forToken.next.next.charOffset));
     }
-    Statement result = new KernelForInStatement(
+    Statement result = new ShadowForInStatement(
         variable, expression, body, declaresVariable,
         isAsync: awaitToken != null)
       ..fileOffset = forToken.charOffset
       ..bodyOffset = body.fileOffset;
     if (breakTarget.hasUsers) {
-      result = new KernelLabeledStatement(result);
+      result = new ShadowLabeledStatement(result);
       breakTarget.resolveBreaks(result);
     }
     exitLoopOrSwitch(result);
   }
 
   @override
   void handleLabel(Token token) {
     debugEvent("Label");
     Identifier identifier = pop();
     push(new Label(identifier.name));
@@ skipping 13 matching lines @@
   }
 
   @override
   void endLabeledStatement(int labelCount) {
     debugEvent("LabeledStatement");
     Statement statement = popStatement();
     LabelTarget target = pop();
     exitLocalScope();
     if (target.breakTarget.hasUsers) {
       if (statement is! LabeledStatement) {
-        statement = new KernelLabeledStatement(statement);
+        statement = new ShadowLabeledStatement(statement);
       }
       target.breakTarget.resolveBreaks(statement);
     }
     if (target.continueTarget.hasUsers) {
       if (statement is! LabeledStatement) {
-        statement = new KernelLabeledStatement(statement);
+        statement = new ShadowLabeledStatement(statement);
       }
       target.continueTarget.resolveContinues(statement);
     }
     push(statement);
   }
 
   @override
   void endRethrowStatement(Token rethrowToken, Token endToken) {
     debugEvent("RethrowStatement");
     if (inCatchBlock) {
-      push(new KernelExpressionStatement(
-          new KernelRethrow()..fileOffset = offsetForToken(rethrowToken)));
+      push(new ShadowExpressionStatement(
+          new ShadowRethrow()..fileOffset = offsetForToken(rethrowToken)));
     } else {
       push(deprecated_buildCompileTimeErrorStatement(
           "'rethrow' can only be used in catch clauses.",
           rethrowToken.charOffset));
     }
   }
 
   @override
   void handleFinallyBlock(Token finallyKeyword) {
     debugEvent("FinallyBlock");
     // Do nothing, handled by [endTryStatement].
   }
 
   @override
   void endWhileStatement(Token whileKeyword, Token endToken) {
     debugEvent("WhileStatement");
     Statement body = popStatement();
     Expression condition = popForValue();
     JumpTarget continueTarget = exitContinueTarget();
     JumpTarget breakTarget = exitBreakTarget();
     if (continueTarget.hasUsers) {
-      body = new KernelLabeledStatement(body);
+      body = new ShadowLabeledStatement(body);
       continueTarget.resolveContinues(body);
     }
-    Statement result = new KernelWhileStatement(condition, body)
+    Statement result = new ShadowWhileStatement(condition, body)
       ..fileOffset = whileKeyword.charOffset;
     if (breakTarget.hasUsers) {
-      result = new KernelLabeledStatement(result);
+      result = new ShadowLabeledStatement(result);
       breakTarget.resolveBreaks(result);
     }
     exitLoopOrSwitch(result);
   }
 
   @override
   void handleEmptyStatement(Token token) {
     debugEvent("EmptyStatement");
     push(new EmptyStatement());
   }
 
   @override
   void beginAssert(Token assertKeyword, Assert kind) {
     debugEvent("beginAssert");
     // If in an assert initializer, make sure [inInitializer] is false so we
     // use the formal parameter scope. If this is any other kind of assert,
     // inInitializer should be false anyway.
     inInitializer = false;
   }
 
   @override
   void endAssert(Token assertKeyword, Assert kind, Token leftParenthesis,
       Token commaToken, Token rightParenthesis, Token semicolonToken) {
     debugEvent("Assert");
     Expression message = popForValueIfNotNull(commaToken);
     Expression condition = popForValue();
-    AssertStatement statement = new KernelAssertStatement(condition,
+    AssertStatement statement = new ShadowAssertStatement(condition,
         conditionStartOffset: leftParenthesis.offset + 1,
         conditionEndOffset: rightParenthesis.offset,
         message: message);
     switch (kind) {
       case Assert.Statement:
         push(statement);
         break;
 
       case Assert.Expression:
         push(deprecated_buildCompileTimeError(
@@ skipping 10 matching lines @@
     // Since kernel only has asserts in statment form, we convert it to an
     // expression by wrapping it in an anonymous function which we call
     // immediately.
     //
     // Additionally, kernel has no initializer that evaluates an expression,
     // but it does have `LocalInitializer` which requires a variable declartion.
     //
     // So we produce an initializer like this:
     //
     //    var #t0 = (() { statement; }) ()
-    return new KernelAssertInitializer(
+    return new ShadowAssertInitializer(
         new VariableDeclaration.forValue(buildMethodInvocation(
             new FunctionExpression(new FunctionNode(statement)),
             callName,
             new Arguments.empty(),
             statement.fileOffset,
             isConstantExpression: true,
             isImplicitCall: true)),
         statement);
   }
 
   @override
   void endYieldStatement(Token yieldToken, Token starToken, Token endToken) {
     debugEvent("YieldStatement");
-    push(new KernelYieldStatement(popForValue(), isYieldStar: starToken != null)
+    push(new ShadowYieldStatement(popForValue(), isYieldStar: starToken != null)
       ..fileOffset = yieldToken.charOffset);
   }
 
   @override
   void beginSwitchBlock(Token token) {
     debugEvent("beginSwitchBlock");
     enterLocalScope("switch block");
     enterSwitchScope();
     enterBreakTarget(token.charOffset);
   }
@@ skipping 50 matching lines @@
 
   @override
   void endSwitchStatement(Token switchKeyword, Token endToken) {
     debugEvent("SwitchStatement");
 
     List<SwitchCase> cases = pop();
     JumpTarget target = exitBreakTarget();
     exitSwitchScope();
     exitLocalScope();
     Expression expression = popForValue();
-    Statement result = new KernelSwitchStatement(expression, cases)
+    Statement result = new ShadowSwitchStatement(expression, cases)
       ..fileOffset = switchKeyword.charOffset;
     if (target.hasUsers) {
-      result = new KernelLabeledStatement(result);
+      result = new ShadowLabeledStatement(result);
       target.resolveBreaks(result);
     }
     exitLoopOrSwitch(result);
   }
 
   @override
   void endSwitchBlock(int caseCount, Token beginToken, Token endToken) {
     debugEvent("SwitchBlock");
     List<SwitchCase> cases =
         new List<SwitchCase>.filled(caseCount, null, growable: true);
@@ skipping 70 matching lines @@
         !target.isBreakTarget) {
       push(compileTimeErrorInLoopOrSwitch =
           deprecated_buildCompileTimeErrorStatement(
               "Can't break to '$name'.", breakKeyword.next.charOffset));
     } else if (target.functionNestingLevel != functionNestingLevel) {
       push(compileTimeErrorInLoopOrSwitch =
           deprecated_buildCompileTimeErrorStatement(
               "Can't break to '$name' in a different function.",
               breakKeyword.next.charOffset));
     } else {
-      BreakStatement statement = new KernelBreakStatement(null)
+      BreakStatement statement = new ShadowBreakStatement(null)
         ..fileOffset = breakKeyword.charOffset;
       target.addBreak(statement);
       push(statement);
     }
   }
 
   @override
   void handleContinueStatement(
       bool hasTarget, Token continueKeyword, Token endToken) {
     debugEvent("ContinueStatement");
@@ skipping 15 matching lines @@
           push(deprecated_buildCompileTimeErrorStatement(
               "Can't find label '$name'.", continueKeyword.next.charOffset));
           return;
         }
         switchScope.forwardDeclareLabel(identifier.name,
             target = createGotoTarget(offsetForToken(identifier.token)));
       }
       if (target.isGotoTarget &&
           target.functionNestingLevel == functionNestingLevel) {
         ContinueSwitchStatement statement =
-            new KernelContinueSwitchStatement(null)
+            new ShadowContinueSwitchStatement(null)
               ..fileOffset = continueKeyword.charOffset;
         target.addGoto(statement);
         push(statement);
         return;
       }
     }
     if (target == null) {
       push(compileTimeErrorInLoopOrSwitch =
           deprecated_buildCompileTimeErrorStatement(
               "No target of continue.", continueKeyword.charOffset));
     } else if (!target.isContinueTarget) {
       push(compileTimeErrorInLoopOrSwitch =
           deprecated_buildCompileTimeErrorStatement(
               "Can't continue at '$name'.", continueKeyword.next.charOffset));
     } else if (target.functionNestingLevel != functionNestingLevel) {
       push(compileTimeErrorInLoopOrSwitch =
           deprecated_buildCompileTimeErrorStatement(
               "Can't continue at '$name' in a different function.",
               continueKeyword.next.charOffset));
     } else {
-      BreakStatement statement = new KernelBreakStatement(null)
+      BreakStatement statement = new ShadowBreakStatement(null)
         ..fileOffset = continueKeyword.charOffset;
       target.addContinue(statement);
       push(statement);
     }
   }
 
   @override
   void endTypeVariable(Token token, Token extendsOrSuper) {
     debugEvent("TypeVariable");
     DartType bound = pop();
@@ skipping 76 matching lines @@
         fasta.templateUnspecified.withArguments(error), charOffset);
   }
 
   @override
   Expression buildCompileTimeError(Message message, int charOffset) {
     // TODO(ahe): This method should be passed the erroneous expression, wrap
     // it in a class (TBD) from which the erroneous expression can be easily
     // extracted. Similar for statements and initializers. See also [issue
     // 29717](https://github.com/dart-lang/sdk/issues/29717)
     library.addCompileTimeError(message, charOffset, uri, wasHandled: true);
-    return new KernelSyntheticExpression(library.loader
+    return new ShadowSyntheticExpression(library.loader
         .throwCompileConstantError(
             library.loader.buildCompileTimeError(message, charOffset, uri)));
   }
 
   Expression wrapInCompileTimeError(Expression expression, Message message) {
     return new Let(
         new VariableDeclaration.forValue(expression)
           ..fileOffset = expression.fileOffset,
         buildCompileTimeError(message, expression.fileOffset))
       ..fileOffset = expression.fileOffset;
@@ skipping 12 matching lines @@
         ]),
         charOffset: charOffset));
   }
 
   Expression buildAbstractClassInstantiationError(String className,
       [int charOffset = -1]) {
     warning(fasta.templateAbstractClassInstantiation.withArguments(className),
         charOffset);
     Builder constructor = library.loader.getAbstractClassInstantiationError();
     return new Throw(buildStaticInvocation(constructor.target,
-        new KernelArguments(<Expression>[new StringLiteral(className)])));
+        new ShadowArguments(<Expression>[new StringLiteral(className)])));
   }
 
   Statement deprecated_buildCompileTimeErrorStatement(error,
       [int charOffset = -1]) {
-    return new KernelExpressionStatement(
+    return new ShadowExpressionStatement(
         deprecated_buildCompileTimeError(error, charOffset));
   }
 
   @override
   Initializer buildInvalidInitializer(Expression expression,
       [int charOffset = -1]) {
     needsImplicitSuperInitializer = false;
-    return new KernelInvalidInitializer(
+    return new ShadowInvalidInitializer(
         new VariableDeclaration.forValue(expression))
       ..fileOffset = charOffset;
   }
 
   Initializer buildDuplicatedInitializer(
       String name, int offset, int previousInitializerOffset) {
     Initializer initializer = buildInvalidInitializer(
         deprecated_buildCompileTimeError(
             "'$name' has already been initialized.", offset),
         offset);
@@ skipping 25 matching lines @@
                 .withArguments(name),
             builder.charOffset);
         Builder constructor =
             library.loader.getDuplicatedFieldInitializerError();
         return buildInvalidInitializer(
             new Throw(buildStaticInvocation(constructor.target,
                 new Arguments(<Expression>[new StringLiteral(name)]),
                 charOffset: offset)),
             offset);
       } else {
-        return new KernelFieldInitializer(builder.field, expression)
+        return new ShadowFieldInitializer(builder.field, expression)
           ..fileOffset = offset
           ..isSynthetic = isSynthetic;
       }
     } else {
       return buildInvalidInitializer(
           deprecated_buildCompileTimeError(
               "'$name' isn't an instance field of this class.", offset),
           offset);
     }
   }
 
   @override
   Initializer buildSuperInitializer(
       bool isSynthetic, Constructor constructor, Arguments arguments,
       [int charOffset = -1]) {
     if (member.isConst && !constructor.isConst) {
       return buildInvalidInitializer(
           deprecated_buildCompileTimeError(
               "Super constructor isn't const.", charOffset),
           charOffset);
     }
     needsImplicitSuperInitializer = false;
-    return new KernelSuperInitializer(constructor, arguments)
+    return new ShadowSuperInitializer(constructor, arguments)
       ..fileOffset = charOffset
       ..isSynthetic = isSynthetic;
   }
 
   @override
   Initializer buildRedirectingInitializer(
       Constructor constructor, Arguments arguments,
       [int charOffset = -1]) {
     needsImplicitSuperInitializer = false;
-    return new KernelRedirectingInitializer(constructor, arguments)
+    return new ShadowRedirectingInitializer(constructor, arguments)
       ..fileOffset = charOffset;
   }
 
   @override
   Expression buildProblemExpression(ProblemBuilder builder, int charOffset) {
     return buildCompileTimeError(builder.message, charOffset);
   }
 
   @override
   void handleOperator(Token token) {
@@ skipping 77 matching lines @@
       Expression receiver, Name name, Arguments arguments, int offset,
       {bool isConstantExpression: false,
       bool isNullAware: false,
       bool isImplicitCall: false}) {
     if (constantExpressionRequired && !isConstantExpression) {
       return deprecated_buildCompileTimeError(
           "Not a constant expression.", offset);
     }
     if (isNullAware) {
       VariableDeclaration variable = new VariableDeclaration.forValue(receiver);
-      return new KernelNullAwareMethodInvocation(
+      return new ShadowNullAwareMethodInvocation(
           variable,
           new ConditionalExpression(
               buildIsNull(new VariableGet(variable), offset),
               new NullLiteral(),
               new MethodInvocation(new VariableGet(variable), name, arguments)
                 ..fileOffset = offset,
               null)
             ..fileOffset = offset)
         ..fileOffset = offset;
     } else {
-      return new KernelMethodInvocation(receiver, name, arguments,
+      return new ShadowMethodInvocation(receiver, name, arguments,
           isImplicitCall: isImplicitCall)
         ..fileOffset = offset;
     }
   }
 
   @override
   void addCompileTimeError(Message message, int charOffset) {
     library.addCompileTimeError(message, charOffset, uri);
   }
 
   @override
   void debugEvent(String name) {
     // printEvent('BodyBuilder: $name');
   }
 
   @override
   StaticGet makeStaticGet(Member readTarget, Token token) {
-    return new KernelStaticGet(readTarget)..fileOffset = offsetForToken(token);
+    return new ShadowStaticGet(readTarget)..fileOffset = offsetForToken(token);
   }
 }
 
 class Identifier {
   final Token token;
   String get name => token.lexeme;
 
   Identifier(this.token);
 
   Expression get initializer => null;
@@ skipping 445 matching lines @@
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return unhandled(asyncToken.lexeme, "asyncMarkerFromTokens",
         asyncToken.charOffset, null);
   }
 }