Fasta type inference prototype #2

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;
 
 import '../parser/identifier_context.dart' show IdentifierContext;
 
+import 'package:front_end/src/fasta/builder/ast_factory.dart';
+import 'package:front_end/src/fasta/kernel/kernel_ast_factory.dart';
+import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart';
+import 'package:front_end/src/fasta/type_inference/local_type_inferrer.dart';
+import '../builder/shadow_ast.dart';
 import 'package:kernel/ast.dart';
 
 import 'package:kernel/clone.dart' show CloneVisitor;
 
 import 'package:kernel/transformations/flags.dart' show TransformerFlag;
 
 import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
 
 import 'package:kernel/core_types.dart' show CoreTypes;
 
@@ skipping 72 matching lines @@
   CloneVisitor cloner;
 
   bool constantExpressionRequired = false;
 
   DartType currentLocalVariableType;
 
   // Using non-null value to initialize this field based on performance advice
   // from VM engineers. TODO(ahe): Does this still apply?
   int currentLocalVariableModifiers = -1;
 
+  final AstFactory _ast = new KernelAstFactory();
+
+  final LocalTypeInferrer _typeInferrer;
+
   BodyBuilder(
       KernelLibraryBuilder library,
       this.member,
       Scope scope,
       this.formalParameterScope,
       this.hierarchy,
-      this.coreTypes,
+      CoreTypes coreTypes,
       this.classBuilder,
       this.isInstanceMember,
       this.uri)
-      : enclosingScope = scope,
+      : coreTypes = coreTypes,
+        enclosingScope = scope,
         library = library,
         isDartLibrary = library.uri.scheme == "dart",
+        // TODO(paulberry): put this behind a flag.
+        _typeInferrer = new LocalTypeInferrer(coreTypes),
         super(scope);
 
   bool get hasParserError => recoverableErrors.isNotEmpty;
 
   bool get inConstructor {
     return functionNestingLevel == 0 && member is KernelConstructorBuilder;
   }
 
   bool get isInstanceContext {
     return isInstanceMember || member is KernelConstructorBuilder;
   }
 
   @override
   void push(Object node) {
     inInitializer = false;
     super.push(node);
   }
 
-  Expression popForValue() => toValue(pop());
+  ShadowExpression popForValue() => toValue(pop());
 
-  Expression popForEffect() => toEffect(pop());
+  ShadowExpression popForEffect() => toEffect(pop());
 
-  Expression popForValueIfNotNull(Object value) {
+  ShadowExpression popForValueIfNotNull(Object value) {
     return value == null ? null : popForValue();
   }
 
   @override
-  Expression toValue(Object node) {
+  ShadowExpression toValue(Object node) {
     if (node is UnresolvedIdentifier) {
       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 _ast.nullLiteral(node.fileOffset);
       }
       return throwNoSuchMethodError(
           node.name.name, new Arguments.empty(), node.fileOffset,
           isGetter: true);
     } else if (node is BuilderAccessor) {
       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);
+        return new TypeLiteral(type) as ShadowExpression;
       }
     } else if (node is TypeDeclarationBuilder) {
-      return new TypeLiteral(node.buildTypesWithBuiltArguments(library, null));
+      return new TypeLiteral(node.buildTypesWithBuiltArguments(library, null))
+          as ShadowExpression;
     } else if (node is KernelTypeBuilder) {
-      return new TypeLiteral(node.build(library));
-    } else if (node is Expression) {
+      return new TypeLiteral(node.build(library)) as ShadowExpression;
+    } else if (node is ShadowExpression) {
       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) {
+  ShadowExpression toEffect(Object node) {
     if (node is BuilderAccessor) return node.buildForEffect();
     return toValue(node);
   }
 
-  List<Expression> popListForValue(int n) {
-    List<Expression> list =
-        new List<Expression>.filled(n, null, growable: true);
+  List<ShadowExpression> popListForValue(int n) {
+    List<ShadowExpression> list = _ast.expressionList(n);
     for (int i = n - 1; i >= 0; i--) {
       list[i] = popForValue();
     }
     return list;
   }
 
-  List<Expression> popListForEffect(int n) {
-    List<Expression> list =
-        new List<Expression>.filled(n, null, growable: true);
+  List<ShadowExpression> popListForEffect(int n) {
+    List<ShadowExpression> list = _ast.expressionList(n);
     for (int i = n - 1; i >= 0; i--) {
       list[i] = popForEffect();
     }
     return list;
   }
 
-  Block popBlock(int count, int charOffset) {
+  ShadowBlock popBlock(int count, int charOffset) {
     List<dynamic /*Statement | List<Statement>*/ > statements =
         popList(count) ?? <Statement>[];
     List<Statement> copy;
     for (int i = 0; i < statements.length; i++) {
       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 Block(copy ?? statements)..fileOffset = charOffset;
+    return _ast.block(copy ?? statements, charOffset);
   }
 
   Statement popStatementIfNotNull(Object value) {
     return value == null ? null : popStatement();
   }
 
   Statement popStatement() {
     var statement = pop();
     if (statement is List) {
       return new Block(new List<Statement>.from(statement));
@@ skipping 95 matching lines @@
     checkEmpty(-1);
   }
 
   @override
   void endBlockFunctionBody(int count, Token beginToken, Token endToken) {
     debugEvent("BlockFunctionBody");
     if (beginToken == null) {
       assert(count == 0);
       push(NullValue.Block);
     } else {
-      Block block = popBlock(count, beginToken.charOffset);
+      ShadowBlock block = popBlock(count, beginToken.charOffset);
       exitLocalScope();
       push(block);
     }
   }
 
   @override
   void prepareInitializers() {
     scope = formalParameterScope;
     assert(fieldInitializers.isEmpty);
     final member = this.member;
@@ skipping 60 matching lines @@
   void handleNoInitializers() {
     debugEvent("NoInitializers");
   }
 
   @override
   void endInitializers(int count, Token beginToken, Token endToken) {
     debugEvent("Initializers");
   }
 
   @override
-  void finishFunction(
-      FormalParameters formals, AsyncMarker asyncModifier, Statement body) {
+  void finishFunction(FormalParameters formals, AsyncMarker asyncModifier,
+      ShadowStatement body) {
     debugEvent("finishFunction");
     KernelFunctionBuilder builder = member;
     if (builder is KernelConstructorBuilder) {
       if (asyncModifier != AsyncMarker.Sync) {
         // TODO(ahe): Change this to a null check.
-        addCompileTimeError(body?.fileOffset,
+        addCompileTimeError((body as Statement)?.fileOffset,
             "Can't be marked as ${asyncModifier}: ${builder.name}");
       }
     } else if (builder is KernelProcedureBuilder) {
       builder.asyncModifier = asyncModifier;
     } else {
       internalError("Unhandled: ${builder.runtimeType}");
     }
-    builder.body = body;
+    _typeInferrer.inferBody(body);
+    builder.body = body as Statement;
     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 NullLiteral();
         realParameter.initializer = initializer..parent = realParameter;
       }
     }
   }
 
   @override
   void endExpressionStatement(Token token) {
     debugEvent("ExpressionStatement");
-    push(new ExpressionStatement(popForEffect()));
+    push(new ExpressionStatement(popForEffect() as Expression));
   }
 
   @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) {
         firstNamedArgumentIndex =
             i < firstNamedArgumentIndex ? i : firstNamedArgumentIndex;
       } else {
         arguments[i] = toValue(node);
         if (i > firstNamedArgumentIndex) {
           arguments[i] = new NamedExpression(
               "#$i",
               buildCompileTimeError(
-                  "Expected named argument.", arguments[i].fileOffset));
+                      "Expected named argument.", arguments[i].fileOffset)
+                  as Expression);
         }
       }
     }
     if (firstNamedArgumentIndex < arguments.length) {
       List<Expression> positional = new List<Expression>.from(
           arguments.getRange(0, firstNamedArgumentIndex));
       List<NamedExpression> named = new List<NamedExpression>.from(
           arguments.getRange(firstNamedArgumentIndex, arguments.length));
       push(new Arguments(positional, named: named));
     } else {
@@ skipping 43 matching lines @@
     if (receiver is BuilderAccessor) {
       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);
+          toValue(receiver) as Expression, callName, arguments, charOffset);
     }
   }
 
   @override
   void beginCascade(Token token) {
     debugEvent("beginCascade");
-    Expression expression = popForValue();
+    Expression expression = popForValue() as Expression;
     if (expression is CascadeReceiver) {
       push(expression);
       push(new VariableAccessor(
           this, expression.fileOffset, expression.variable));
       expression.extend();
     } else {
       VariableDeclaration variable =
           new VariableDeclaration.forValue(expression);
       push(new CascadeReceiver(variable));
       push(new VariableAccessor(this, expression.fileOffset, variable));
     }
   }
 
   @override
   void endCascade() {
     debugEvent("endCascade");
-    Expression expression = popForEffect();
+    Expression expression = popForEffect() as Expression;
     CascadeReceiver cascadeReceiver = pop();
     cascadeReceiver.finalize(expression);
     push(cascadeReceiver);
   }
 
   @override
   void handleBinaryExpression(Token token) {
     debugEvent("BinaryExpression");
     if (optional(".", token) || optional("..", token)) {
       return doDotOrCascadeExpression(token);
     }
     if (optional("&&", token) || optional("||", token)) {
       return doLogicalExpression(token);
     }
     if (optional("??", token)) return doIfNull(token);
     if (optional("?.", token)) return doIfNotNull(token);
-    Expression argument = popForValue();
+    Expression argument = popForValue() as Expression;
     var receiver = pop();
     bool isSuper = false;
     if (receiver is ThisAccessor && receiver.isSuper) {
       isSuper = true;
       receiver = new ThisExpression();
     }
-    push(buildBinaryOperator(toValue(receiver), token, argument, isSuper));
+    push(buildBinaryOperator(
+        toValue(receiver) as Expression, 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 buildCompileTimeError(
-          "Not an operator: '$operator'.", token.charOffset);
+          "Not an operator: '$operator'.", token.charOffset) as Expression;
     } else {
       Expression result =
           makeBinary(a, new Name(operator), null, b, token.charOffset);
       if (isSuper) {
         result = toSuperMethodInvocation(result);
       }
       return negate ? new Not(result) : result;
     }
   }
 
   void doLogicalExpression(Token token) {
-    Expression argument = popForValue();
-    Expression receiver = popForValue();
+    Expression argument = popForValue() as Expression;
+    Expression receiver = popForValue() as Expression;
     push(new LogicalExpression(receiver, token.stringValue, argument));
   }
 
   /// Handle `a ?? b`.
   void doIfNull(Token token) {
-    Expression b = popForValue();
-    Expression a = popForValue();
+    Expression b = popForValue() as Expression;
+    Expression a = popForValue() as Expression;
     VariableDeclaration variable = new VariableDeclaration.forValue(a);
     push(makeLet(
         variable,
         new ConditionalExpression(buildIsNull(new VariableGet(variable)), b,
             new VariableGet(variable), const DynamicType())));
   }
 
   /// Handle `a?.b(...)`.
   void doIfNotNull(Token token) {
     IncompleteSend send = pop();
@@ skipping 19 matching lines @@
               new ThisExpression(), target, node.arguments);
           result = new SuperMethodInvocation(node.name, node.arguments, null);
           return result;
         } else {
           isNoSuchMethod = true;
         }
       }
     }
     if (isNoSuchMethod) {
       return throwNoSuchMethodError(
-          node.name.name, node.arguments, node.fileOffset,
-          isSuper: true);
+              node.name.name, node.arguments, node.fileOffset, isSuper: true)
+          as Expression;
     }
     // TODO(ahe): Use [DirectPropertyGet] when possible.
     Expression receiver = new DirectPropertyGet(new ThisExpression(), target);
     receiver = new SuperPropertyGet(node.name, target);
     return buildMethodInvocation(
         receiver, callName, node.arguments, node.fileOffset);
   }
 
   bool areArgumentsCompatible(FunctionNode function, Arguments arguments) {
     // TODO(ahe): Implement this.
     return true;
   }
 
   @override
-  Expression throwNoSuchMethodError(
+  ShadowExpression throwNoSuchMethodError(
       String name, Arguments arguments, int charOffset,
       {bool isSuper: false, isGetter: false, isSetter: false}) {
     String errorName = isSuper ? "super.$name" : name;
     if (isGetter) {
       warning("Getter not found: '$errorName'.", charOffset);
     } else if (isSetter) {
       warning("Setter not found: '$errorName'.", charOffset);
     } else {
       warning("Method not found: '$errorName'.", charOffset);
     }
     Constructor constructor =
         coreTypes.getClass("dart:core", "NoSuchMethodError").constructors.first;
     return new Throw(new ConstructorInvocation(
         constructor,
         new Arguments(<Expression>[
           new NullLiteral(),
           new SymbolLiteral(name),
           new ListLiteral(arguments.positional),
           new MapLiteral(arguments.named.map((arg) {
             return new MapEntry(new SymbolLiteral(arg.name), arg.value);
           }).toList()),
           new NullLiteral()
-        ])));
+        ]))) as ShadowExpression;
   }
 
   @override
   Member lookupSuperMember(Name name, {bool isSetter: false}) {
     Class superclass = classBuilder.cls.superclass;
     return superclass == null
         ? null
         : hierarchy.getDispatchTarget(superclass, name, setter: isSetter);
   }
 
@@ skipping 146 matching lines @@
         expressions.add(
             new StringLiteral(unescapeFirstStringPart(first.lexeme, quote)));
       }
       for (int i = 1; i < parts.length - 1; i++) {
         var part = parts[i];
         if (part is Token) {
           if (part.lexeme.length != 0) {
             expressions.add(new StringLiteral(unescape(part.lexeme, quote)));
           }
         } else {
-          expressions.add(toValue(part));
+          expressions.add(toValue(part) as Expression);
         }
       }
       // Contains more than just \' or \".
       if (last.lexeme.length > 1) {
         expressions
             .add(new StringLiteral(unescapeLastStringPart(last.lexeme, quote)));
       }
       push(new StringConcatenation(expressions)
         ..fileOffset = endToken.charOffset);
     }
   }
 
   @override
   void handleScript(Token token) {
     debugEvent("Script");
   }
 
   @override
   void handleStringJuxtaposition(int literalCount) {
     debugEvent("StringJuxtaposition");
-    List<Expression> parts = popListForValue(literalCount);
+    List<Expression> parts = popListForValue(literalCount) as List<Expression>;
     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 StringConcatenation(expressions ?? parts));
   }
 
   @override
   void handleLiteralInt(Token token) {
     debugEvent("LiteralInt");
-    push(
-        new IntLiteral(int.parse(token.lexeme))..fileOffset = token.charOffset);
+    push(_ast.intLiteral(int.parse(token.lexeme), token.charOffset));
   }
 
   @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;
+    ShadowExpression expression = hasExpression ? popForValue() : null;
     if (expression != null && inConstructor) {
       push(buildCompileTimeErrorStatement(
           "Can't return from a constructor.", beginToken.charOffset));
     } else {
-      push(new ReturnStatement(expression)..fileOffset = beginToken.charOffset);
+      push(_ast.returnStatement(expression, beginToken.charOffset));
     }
   }
 
   @override
   void endIfStatement(Token ifToken, Token elseToken) {
     Statement elsePart = popStatementIfNotNull(elseToken);
     Statement thenPart = popStatement();
-    Expression condition = popForValue();
+    Expression condition = popForValue() as Expression;
     push(new IfStatement(condition, thenPart, elsePart));
   }
 
   @override
   void endVariableInitializer(Token assignmentOperator) {
     debugEvent("VariableInitializer");
     assert(assignmentOperator.stringValue == "=");
     pushNewLocalVariable(popForValue(),
         equalsCharOffset: assignmentOperator.charOffset);
   }
 
   @override
   void handleNoVariableInitializer(Token token) {
     debugEvent("NoVariableInitializer");
     pushNewLocalVariable(null);
   }
 
-  void pushNewLocalVariable(Expression initializer,
+  void pushNewLocalVariable(ShadowExpression initializer,
       {int equalsCharOffset: TreeNode.noOffset}) {
     Identifier identifier = pop();
     assert(currentLocalVariableModifiers != -1);
     bool isConst = (currentLocalVariableModifiers & constMask) != 0;
     bool isFinal = (currentLocalVariableModifiers & finalMask) != 0;
     assert(isConst == constantExpressionRequired);
-    push(new VariableDeclaration(identifier.name,
+    var variable = _ast.variableDeclaration(identifier.name,
         initializer: initializer,
-        type: currentLocalVariableType ?? const DynamicType(),
+        type: currentLocalVariableType,
         isFinal: isFinal,
-        isConst: isConst)..fileEqualsOffset = equalsCharOffset);
+        isConst: isConst,
+        charOffset: equalsCharOffset);
+    _typeInferrer.finishVariableDeclaration(
+        currentLocalVariableType, initializer, variable);
+    push(variable);
   }
 
   @override
   void endFieldInitializer(Token assignmentOperator) {
     debugEvent("FieldInitializer");
     assert(assignmentOperator.stringValue == "=");
     push(popForValue());
   }
 
   @override
@@ skipping 36 matching lines @@
     if (variables.length != 1) {
       push(variables);
     } else {
       push(variables.single);
     }
   }
 
   @override
   void endBlock(int count, Token beginToken, Token endToken) {
     debugEvent("Block");
-    Block block = popBlock(count, beginToken.charOffset);
+    ShadowBlock block = popBlock(count, beginToken.charOffset);
     exitLocalScope();
     push(block);
   }
 
   @override
   void handleAssignmentExpression(Token token) {
     debugEvent("AssignmentExpression");
-    Expression value = popForValue();
+    Expression value = popForValue() as Expression;
     var accessor = pop();
     if (accessor is TypeDeclarationBuilder) {
       push(wrapInvalid(new TypeLiteral(
           accessor.buildTypesWithBuiltArguments(library, null))));
     } else if (accessor is! BuilderAccessor) {
       push(buildCompileTimeError("Can't assign to this.", token.charOffset));
     } else {
       push(new DelayedAssignment(
           this, token.charOffset, accessor, value, token.stringValue));
     }
@@ skipping 18 matching lines @@
     } else {
       push(statement);
     }
   }
 
   @override
   void endForStatement(Token forKeyword, Token leftSeparator,
       int updateExpressionCount, Token endToken) {
     debugEvent("ForStatement");
     Statement body = popStatement();
-    List<Expression> updates = popListForEffect(updateExpressionCount);
+    List<Expression> updates =
+        popListForEffect(updateExpressionCount) as List<Expression>;
     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;
@@ skipping 27 matching lines @@
     if (breakTarget.hasUsers) {
       result = new LabeledStatement(result);
       breakTarget.resolveBreaks(result);
     }
     exitLoopOrSwitch(result);
   }
 
   @override
   void endAwaitExpression(Token beginToken, Token endToken) {
     debugEvent("AwaitExpression");
-    push(
-        new AwaitExpression(popForValue())..fileOffset = beginToken.charOffset);
+    push(new AwaitExpression(popForValue() as Expression)
+      ..fileOffset = beginToken.charOffset);
   }
 
   @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<ShadowExpression> expressions = popListForValue(count);
     List<DartType> typeArguments = pop();
-    DartType typeArgument = const DynamicType();
+    DartType typeArgument;
     if (typeArguments != null) {
       typeArgument = typeArguments.first;
       if (typeArguments.length > 1) {
-        typeArgument = const DynamicType();
+        typeArgument = null;
         warning(
             "Too many type arguments on List literal.", beginToken.charOffset);
       }
     }
-    push(new ListLiteral(expressions,
-        typeArgument: typeArgument, isConst: constKeyword != null)
-      ..fileOffset = constKeyword?.charOffset ?? beginToken.charOffset);
+    push(_ast.listLiteral(expressions, typeArgument, constKeyword != null,
+        constKeyword?.charOffset ?? beginToken.charOffset));
   }
 
   @override
   void handleLiteralBool(Token token) {
     debugEvent("LiteralBool");
     bool value = optional("true", token);
     assert(value || optional("false", token));
     push(new BoolLiteral(value)..fileOffset = token.charOffset);
   }
 
   @override
   void handleLiteralDouble(Token token) {
     debugEvent("LiteralDouble");
     push(new DoubleLiteral(double.parse(token.lexeme))
       ..fileOffset = token.charOffset);
   }
 
   @override
   void handleLiteralNull(Token token) {
     debugEvent("LiteralNull");
-    push(new NullLiteral()..fileOffset = token.charOffset);
+    push(_ast.nullLiteral(token.charOffset));
   }
 
   @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 = const DynamicType();
     DartType valueType = const DynamicType();
     if (typeArguments != null) {
       if (typeArguments.length != 2) {
         keyType = const DynamicType();
         valueType = const DynamicType();
         warning(
             "Map literal requires two type arguments.", beginToken.charOffset);
       } else {
         keyType = typeArguments[0];
         valueType = typeArguments[1];
       }
     }
     push(new MapLiteral(entries,
         keyType: keyType, valueType: valueType, isConst: constKeyword != null)
       ..fileOffset = constKeyword?.charOffset ?? beginToken.charOffset);
   }
 
   @override
   void endLiteralMapEntry(Token colon, Token endToken) {
     debugEvent("LiteralMapEntry");
-    Expression value = popForValue();
-    Expression key = popForValue();
+    Expression value = popForValue() as Expression;
+    Expression key = popForValue() as Expression;
     push(new MapEntry(key, value));
   }
 
   String symbolPartToString(name) {
     if (name is Identifier) {
       return name.name;
     } else if (name is Operator) {
       return name.name;
     } else {
       return internalError("Unhandled: ${name.runtimeType}");
@@ skipping 119 matching lines @@
   @override
   void handleVoidKeyword(Token token) {
     debugEvent("VoidKeyword");
     push(const VoidType());
   }
 
   @override
   void handleAsOperator(Token operator, Token endToken) {
     debugEvent("AsOperator");
     DartType type = pop();
-    Expression expression = popForValue();
+    Expression expression = popForValue() as Expression;
     push(new AsExpression(expression, type)..fileOffset = operator.charOffset);
   }
 
   @override
   void handleIsOperator(Token operator, Token not, Token endToken) {
     debugEvent("IsOperator");
     DartType type = pop();
-    Expression expression = popForValue();
+    Expression expression = popForValue() as Expression;
     expression = new IsExpression(expression, type)
       ..fileOffset = operator.charOffset;
     if (not != null) {
       expression = new Not(expression);
     }
     push(expression);
   }
 
   @override
   void handleConditionalExpression(Token question, Token colon) {
     debugEvent("ConditionalExpression");
-    Expression elseExpression = popForValue();
-    Expression thenExpression = popForValue();
-    Expression condition = popForValue();
+    Expression elseExpression = popForValue() as Expression;
+    Expression thenExpression = popForValue() as Expression;
+    Expression condition = popForValue() as Expression;
     push(new ConditionalExpression(
         condition, thenExpression, elseExpression, const DynamicType()));
   }
 
   @override
   void endThrowExpression(Token throwToken, Token endToken) {
     debugEvent("ThrowExpression");
-    Expression expression = popForValue();
+    Expression expression = popForValue() as Expression;
     push(new Throw(expression)..fileOffset = throwToken.charOffset);
   }
 
   @override
   void endFormalParameter(Token covariantKeyword, Token thisKeyword,
       Token nameToken, FormalParameterType kind) {
     debugEvent("FormalParameter");
     // TODO(ahe): Need beginToken here.
     int charOffset = thisKeyword?.charOffset;
     if (thisKeyword != null) {
       if (!inConstructor) {
         addCompileTimeError(thisKeyword.charOffset,
             "'this' parameters can only be used on constructors.");
         thisKeyword = null;
       }
     }
     Identifier name = pop();
     DartType type = pop();
     pop(); // Modifiers.
     ignore(Unhandled.Metadata);
-    VariableDeclaration variable;
+    ShadowVariableDeclaration variable;
     if (!inCatchClause && functionNestingLevel == 0) {
       dynamic builder = formalParameterScope.lookup(name.name, charOffset, uri);
       if (builder == null) {
         if (thisKeyword == null) {
           internalError("Internal error: formal missing for '${name.name}'");
         } else {
           addCompileTimeError(thisKeyword.charOffset,
               "'${name.name}' isn't a field in this class.");
           thisKeyword = null;
         }
       } else if (thisKeyword == null) {
         variable = builder.build(library);
-        variable.initializer = name.initializer;
+        (variable as VariableDeclaration).initializer = name.initializer;
       } else if (builder.isField && builder.parent == classBuilder) {
         FieldBuilder field = builder;
         if (type != null) {
           nit("Ignoring type on 'this' parameter '${name.name}'.",
               thisKeyword.charOffset);
         }
         type = field.target.type ?? const DynamicType();
-        variable = new VariableDeclaration(name.name,
-            type: type, initializer: name.initializer);
+        variable = _ast.variableDeclaration(name.name,
+            type: type,
+            initializer: name.initializer as ShadowExpression,
+            charOffset: name.fileOffset);
       } else {
         addCompileTimeError(
             name.fileOffset, "'${name.name}' isn't a field in this class.");
       }
     }
-    variable ??= new VariableDeclaration(name.name,
-        type: type ?? const DynamicType(),
-        initializer: name.initializer)..fileOffset = name.fileOffset;
+    variable ??= _ast.variableDeclaration(name.name,
+        type: type,
+        initializer: name.initializer as ShadowExpression,
+        charOffset: name.fileOffset);
     push(variable);
   }
 
   @override
   void endOptionalFormalParameters(
       int count, Token beginToken, Token endToken) {
     debugEvent("OptionalFormalParameters");
     FormalParameterType kind = optional("{", beginToken)
         ? FormalParameterType.NAMED
         : FormalParameterType.POSITIONAL;
@@ skipping 18 matching lines @@
     Identifier name = pop();
     DartType returnType = pop();
     push(formals.toFunctionType(returnType));
     push(name);
     functionNestingLevel--;
   }
 
   @override
   void handleValuedFormalParameter(Token equals, Token token) {
     debugEvent("ValuedFormalParameter");
-    Expression initializer = popForValue();
+    Expression initializer = popForValue() as Expression;
     Identifier name = pop();
     push(new InitializedIdentifier(name.name, initializer));
   }
 
   @override
   void handleFormalParameterWithoutValue(Token token) {
     debugEvent("FormalParameterWithoutValue");
   }
 
   @override
@@ skipping 77 matching lines @@
   @override
   void handleNoExpression(Token token) {
     debugEvent("NoExpression");
     push(NullValue.Expression);
   }
 
   @override
   void handleIndexedExpression(
       Token openCurlyBracket, Token closeCurlyBracket) {
     debugEvent("IndexedExpression");
-    Expression index = popForValue();
+    Expression index = popForValue() as Expression;
     var receiver = pop();
     if (receiver is ThisAccessor && receiver.isSuper) {
       push(new SuperIndexAccessor(this, receiver.charOffset, index,
           lookupSuperMember(indexGetName), lookupSuperMember(indexSetName)));
     } else {
       push(IndexAccessor.make(this, openCurlyBracket.charOffset,
-          toValue(receiver), index, null, null));
+          toValue(receiver) as Expression, index, null, null));
     }
   }
 
   @override
   void handleUnaryPrefixExpression(Token token) {
     debugEvent("UnaryPrefixExpression");
     var receiver = pop();
     if (optional("!", token)) {
-      push(new Not(toValue(receiver)));
+      push(new Not(toValue(receiver) as Expression));
     } else {
       String operator = token.stringValue;
       if (optional("-", token)) {
         operator = "unary-";
       }
       if (receiver is ThisAccessor && receiver.isSuper) {
         push(toSuperMethodInvocation(buildMethodInvocation(
             new ThisExpression()..fileOffset = receiver.charOffset,
             new Name(operator),
             new Arguments.empty(),
             token.charOffset)));
       } else {
-        push(buildMethodInvocation(toValue(receiver), new Name(operator),
-            new Arguments.empty(), token.charOffset));
+        push(buildMethodInvocation(toValue(receiver) as Expression,
+            new Name(operator), new Arguments.empty(), token.charOffset));
       }
     }
   }
 
   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) {
       push(accessor.buildPrefixIncrement(
           incrementOperator(token), token.charOffset));
     } else {
-      push(wrapInvalid(toValue(accessor)));
+      push(wrapInvalid(toValue(accessor) as Expression));
     }
   }
 
   @override
   void handleUnaryPostfixAssignmentExpression(Token token) {
     debugEvent("UnaryPostfixAssignmentExpression");
     var accessor = pop();
     if (accessor is BuilderAccessor) {
       push(new DelayedPostfixIncrement(
           this, token.charOffset, accessor, incrementOperator(token), null));
     } else {
-      push(wrapInvalid(toValue(accessor)));
+      push(wrapInvalid(toValue(accessor) as Expression));
     }
   }
 
   @override
   void endConstructorReference(
       Token start, Token periodBeforeName, Token endToken) {
     debugEvent("ConstructorReference");
     // A constructor reference can contain up to three identifiers:
     //
     //     a) type <type-arguments>?
@@ skipping 47 matching lines @@
   }
 
   @override
   Expression buildStaticInvocation(Member target, Arguments arguments,
       {bool isConst: false, int charOffset: -1}) {
     List<TypeParameter> typeParameters = target.function.typeParameters;
     if (target is Constructor) {
       typeParameters = target.enclosingClass.typeParameters;
     }
     if (!checkArguments(target.function, arguments, typeParameters)) {
-      return throwNoSuchMethodError(target.name.name, arguments, charOffset);
+      return throwNoSuchMethodError(target.name.name, arguments, charOffset)
+          as Expression;
     }
     if (target is Constructor) {
       return new ConstructorInvocation(target, arguments)
         ..isConst = isConst
         ..fileOffset = charOffset;
     } else {
       return new StaticInvocation(target, arguments)
         ..isConst = isConst
         ..fileOffset = charOffset;
     }
@@ skipping 140 matching lines @@
           isSuper: true));
     } else {
       push(new IncompleteError(
           this, token.charOffset, "Expected identifier, but got 'super'."));
     }
   }
 
   @override
   void handleNamedArgument(Token colon) {
     debugEvent("NamedArgument");
-    Expression value = popForValue();
+    Expression value = popForValue() as Expression;
     Identifier identifier = pop();
     push(new NamedExpression(identifier.name, value));
   }
 
   @override
   void endFunctionName(Token beginToken, Token token) {
     debugEvent("FunctionName");
     Identifier name = pop();
     VariableDeclaration variable =
         new VariableDeclaration(name.name, isFinal: true);
     push(new FunctionDeclaration(
         variable, new FunctionNode(new InvalidStatement()))
       ..fileOffset = beginToken.charOffset);
     scope[variable.name] = new KernelVariableBuilder(
         variable, member ?? classBuilder ?? library, uri);
     enterLocalScope();
   }
 
-  void enterFunction() {
+  void enterFunction(bool isNamed) {
     debugEvent("enterFunction");
     functionNestingLevel++;
     push(switchScope ?? NullValue.SwitchScope);
     switchScope = null;
   }
 
   void exitFunction() {
     debugEvent("exitFunction");
     functionNestingLevel--;
     switchScope = pop();
   }
 
   @override
   void beginFunction(Token token) {
     debugEvent("beginFunction");
-    enterFunction();
+    enterFunction(true);
   }
 
   @override
   void beginUnnamedFunction(Token token) {
     debugEvent("beginUnnamedFunction");
-    enterFunction();
+    enterFunction(false);
   }
 
   @override
   void endFunction(Token getOrSet, Token endToken) {
     debugEvent("Function");
     Statement body = popStatement();
     AsyncMarker asyncModifier = pop();
     if (functionNestingLevel != 0) {
       exitLocalScope();
     }
@@ skipping 25 matching lines @@
     Statement body = popStatement();
     AsyncMarker asyncModifier = pop();
     exitLocalScope();
     FormalParameters formals = pop();
     exitFunction();
     List<TypeParameter> typeParameters = pop();
     FunctionNode function = formals.addToFunction(new FunctionNode(body,
         typeParameters: typeParameters, asyncMarker: asyncModifier)
       ..fileOffset = beginToken.charOffset
       ..fileEndOffset = token.charOffset);
-    push(new FunctionExpression(function)..fileOffset = beginToken.charOffset);
+    push(new KernelFunctionExpression(function)
+      ..fileOffset = beginToken.charOffset);
   }
 
   @override
   void endDoWhileStatement(
       Token doKeyword, Token whileKeyword, Token endToken) {
     debugEvent("DoWhileStatement");
-    Expression condition = popForValue();
+    Expression condition = popForValue() as Expression;
     Statement body = popStatement();
     JumpTarget continueTarget = exitContinueTarget();
     JumpTarget breakTarget = exitBreakTarget();
     if (continueTarget.hasUsers) {
       body = new LabeledStatement(body);
       continueTarget.resolveContinues(body);
     }
     Statement result = new DoStatement(body, condition);
     if (breakTarget.hasUsers) {
       result = new LabeledStatement(result);
       breakTarget.resolveBreaks(result);
     }
     exitLoopOrSwitch(result);
   }
 
   @override
   void beginForInExpression(Token token) {
     enterLocalScope(scope.parent);
   }
 
   @override
   void endForInExpression(Token token) {
     debugEvent("ForInExpression");
-    Expression expression = popForValue();
+    Expression expression = popForValue() as Expression;
     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();
+    Expression expression = popForValue() as Expression;
     var lvalue = pop();
     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) {
       /// 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 ExpressionStatement(lvalue
               .buildAssignment(new VariableGet(variable), voidContext: true)),
           body);
     } else {
       variable = new VariableDeclaration.forValue(buildCompileTimeError(
-          "Expected lvalue, but got ${lvalue}", forToken.next.next.charOffset));
+          "Expected lvalue, but got ${lvalue}",
+          forToken.next.next.charOffset) as Expression);
     }
     Statement result = new ForInStatement(variable, expression, body,
         isAsync: awaitToken != null)..fileOffset = body.fileOffset;
     if (breakTarget.hasUsers) {
       result = new LabeledStatement(result);
       breakTarget.resolveBreaks(result);
     }
     exitLoopOrSwitch(result);
   }
 
@@ skipping 48 matching lines @@
   @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();
+    Expression condition = popForValue() as Expression;
     JumpTarget continueTarget = exitContinueTarget();
     JumpTarget breakTarget = exitBreakTarget();
     if (continueTarget.hasUsers) {
       body = new LabeledStatement(body);
       continueTarget.resolveContinues(body);
     }
     Statement result = new WhileStatement(condition, body);
     if (breakTarget.hasUsers) {
       result = new LabeledStatement(result);
       breakTarget.resolveBreaks(result);
     }
     exitLoopOrSwitch(result);
   }
 
   @override
   void handleEmptyStatement(Token token) {
     debugEvent("EmptyStatement");
     push(new EmptyStatement());
   }
 
   @override
   void handleAssertStatement(Token assertKeyword, Token leftParenthesis,
       Token commaToken, Token rightParenthesis, Token semicolonToken) {
     debugEvent("AssertStatement");
-    Expression message = popForValueIfNotNull(commaToken);
-    Expression condition = popForValue();
+    Expression message = popForValueIfNotNull(commaToken) as Expression;
+    Expression condition = popForValue() as Expression;
     push(new AssertStatement(condition, message));
   }
 
   @override
   void endYieldStatement(Token yieldToken, Token starToken, Token endToken) {
     debugEvent("YieldStatement");
-    push(new YieldStatement(popForValue(), isYieldStar: starToken != null)
-      ..fileOffset = yieldToken.charOffset);
+    push(new YieldStatement(popForValue() as Expression,
+        isYieldStar: starToken != null)..fileOffset = yieldToken.charOffset);
   }
 
   @override
   void beginSwitchBlock(Token token) {
     debugEvent("beginSwitchBlock");
     enterLocalScope();
     enterSwitchScope();
     enterBreakTarget(token.charOffset);
   }
 
   @override
   void beginSwitchCase(int labelCount, int expressionCount, Token firstToken) {
     debugEvent("beginSwitchCase");
     List labelsAndExpressions = popList(labelCount + expressionCount);
     List<Label> labels = <Label>[];
     List<Expression> expressions = <Expression>[];
     if (labelsAndExpressions != null) {
       for (var labelOrExpression in labelsAndExpressions) {
         if (labelOrExpression is Label) {
           labels.add(labelOrExpression);
         } else {
-          expressions.add(toValue(labelOrExpression));
+          expressions.add(toValue(labelOrExpression) as Expression);
         }
       }
     }
     assert(scope == switchScope);
     for (Label label in labels) {
       if (scope.hasLocalLabel(label.name)) {
         // TODO(ahe): Should validate this is a goto target and not duplicated.
         scope.claimLabel(label.name);
       } else {
         scope.declareLabel(label.name, createGotoTarget(firstToken.charOffset));
       }
     }
     push(expressions);
     push(labels);
     enterLocalScope();
   }
 
   @override
   void handleSwitchCase(
       int labelCount,
       int expressionCount,
       Token defaultKeyword,
       int statementCount,
       Token firstToken,
       Token endToken) {
     debugEvent("SwitchCase");
-    Block block = popBlock(statementCount, firstToken.charOffset);
+    Block block = popBlock(statementCount, firstToken.charOffset) as Block;
     exitLocalScope();
     List<Label> labels = pop();
     List<Expression> expressions = pop();
     List<int> expressionOffsets = <int>[];
     for (Expression expression in expressions) {
       expressionOffsets.add(expression.fileOffset);
     }
     push(new SwitchCase(expressions, expressionOffsets, block,
         isDefault: defaultKeyword != null)..fileOffset = firstToken.charOffset);
     push(labels);
@@ skipping 17 matching lines @@
         JumpTarget target = switchScope.lookupLabel(label.name);
         if (target != null) {
           target.resolveGotos(current);
         }
       }
       // TODO(ahe): Validate that there's only one default and it's last.
     }
     JumpTarget target = exitBreakTarget();
     exitSwitchScope();
     exitLocalScope();
-    Expression expression = popForValue();
+    Expression expression = popForValue() as Expression;
     Statement result = new SwitchStatement(expression, cases);
     if (target.hasUsers) {
       result = new LabeledStatement(result);
       target.resolveBreaks(result);
     }
     exitLoopOrSwitch(result);
   }
 
   @override
   void handleCaseMatch(Token caseKeyword, Token colon) {
@@ skipping 132 matching lines @@
       if (trailing.contains(token.stringValue) && trailing.contains(expected)) {
         arguments.putIfAbsent("actual", () => token.lexeme);
         handleRecoverableError(token, ErrorKind.ExpectedButGot, arguments);
         return newSyntheticToken(token);
       }
     }
     return super.handleUnrecoverableError(token, kind, arguments);
   }
 
   @override
-  Expression buildCompileTimeError(error, [int charOffset = -1]) {
+  ShadowExpression buildCompileTimeError(error, [int charOffset = -1]) {
     addCompileTimeError(charOffset, error);
     String message = formatUnexpected(uri, charOffset, error);
     Builder constructor = library.loader.getCompileTimeError();
     return new Throw(buildStaticInvocation(constructor.target,
-        new Arguments(<Expression>[new StringLiteral(message)]),
-        isConst: false)); // TODO(ahe): Make this const.
+            new Arguments(<Expression>[new StringLiteral(message)]),
+            isConst: false) as Expression)
+        as ShadowExpression; // TODO(ahe): Make this const.
   }
 
   Statement buildCompileTimeErrorStatement(error, [int charOffset = -1]) {
-    return new ExpressionStatement(buildCompileTimeError(error, charOffset));
+    return new ExpressionStatement(
+        buildCompileTimeError(error, charOffset) as Expression);
   }
 
   @override
   Initializer buildCompileTimeErrorIntializer(error, [int charOffset = -1]) {
     return new LocalInitializer(new VariableDeclaration.forValue(
-        buildCompileTimeError(error, charOffset)));
+        buildCompileTimeError(error, charOffset) as Expression));
   }
 
   @override
-  Expression buildProblemExpression(ProblemBuilder builder, int charOffset) {
+  ShadowExpression buildProblemExpression(
+      ProblemBuilder builder, int charOffset) {
     return buildCompileTimeError(builder.message, charOffset);
   }
 
   @override
   void handleOperator(Token token) {
     debugEvent("Operator");
     push(new Operator(token.stringValue)..fileOffset = token.charOffset);
   }
 
   @override
@@ skipping 114 matching lines @@
   final BuilderAccessor accessor;
 
   ContextAccessor(this.helper, this.charOffset, this.accessor);
 
   String get plainNameForRead => internalError("Unsupported operation.");
 
   Expression doInvocation(int charOffset, Arguments arguments) {
     return internalError("Unhandled: ${runtimeType}", uri, charOffset);
   }
 
-  Expression buildSimpleRead();
+  ShadowExpression buildSimpleRead();
 
-  Expression buildForEffect();
+  ShadowExpression buildForEffect();
 
   Expression buildAssignment(Expression value, {bool voidContext: false}) {
     return makeInvalidWrite(value);
   }
 
   Expression buildNullAwareAssignment(Expression value, DartType type,
       {bool voidContext: false}) {
     return makeInvalidWrite(value);
   }
 
@@ skipping 10 matching lines @@
 
   Expression buildPostfixIncrement(Name binaryOperator, int charOffset,
       {bool voidContext: false, Procedure interfaceTarget}) {
     return makeInvalidWrite(null);
   }
 
   makeInvalidRead() => internalError("not supported");
 
   Expression makeInvalidWrite(Expression value) {
     return helper.buildCompileTimeError(
-        "Can't be used as left-hand side of assignment.", charOffset);
+            "Can't be used as left-hand side of assignment.", charOffset)
+        as Expression;
   }
 }
 
 class DelayedAssignment extends ContextAccessor {
   final Expression value;
 
   final String assignmentOperator;
 
   DelayedAssignment(BuilderHelper helper, int charOffset,
       BuilderAccessor accessor, this.value, this.assignmentOperator)
       : super(helper, charOffset, accessor);
 
-  Expression buildSimpleRead() {
-    return handleAssignment(false);
+  ShadowExpression buildSimpleRead() {
+    return handleAssignment(false) as ShadowExpression;
   }
 
-  Expression buildForEffect() {
-    return handleAssignment(true);
+  ShadowExpression buildForEffect() {
+    return handleAssignment(true) as ShadowExpression;
   }
 
   Expression handleAssignment(bool voidContext) {
     if (identical("=", assignmentOperator)) {
       return accessor.buildAssignment(value, voidContext: voidContext);
     } else if (identical("+=", assignmentOperator)) {
       return accessor.buildCompoundAssignment(plusName, value, charOffset,
           voidContext: voidContext);
     } else if (identical("-=", assignmentOperator)) {
       return accessor.buildCompoundAssignment(minusName, value, charOffset,
@@ skipping 52 matching lines @@
 
 class DelayedPostfixIncrement extends ContextAccessor {
   final Name binaryOperator;
 
   final Procedure interfaceTarget;
 
   DelayedPostfixIncrement(BuilderHelper helper, int charOffset,
       BuilderAccessor accessor, this.binaryOperator, this.interfaceTarget)
       : super(helper, charOffset, accessor);
 
-  Expression buildSimpleRead() {
+  ShadowExpression buildSimpleRead() {
     return accessor.buildPostfixIncrement(binaryOperator, charOffset,
-        voidContext: false, interfaceTarget: interfaceTarget);
+        voidContext: false,
+        interfaceTarget: interfaceTarget) as ShadowExpression;
   }
 
-  Expression buildForEffect() {
+  ShadowExpression buildForEffect() {
     return accessor.buildPostfixIncrement(binaryOperator, charOffset,
-        voidContext: true, interfaceTarget: interfaceTarget);
+        voidContext: true,
+        interfaceTarget: interfaceTarget) as ShadowExpression;
   }
 }
 
 class JumpTarget extends Builder {
   final List<Statement> users = <Statement>[];
 
   final JumpTargetKind kind;
 
   final int functionNestingLevel;
 
@@ skipping 212 matching lines @@
   } else if (node is PrefixBuilder) {
     return node.name;
   } else if (node is ThisAccessor) {
     return node.isSuper ? "super" : "this";
   } else if (node is BuilderAccessor) {
     return node.plainNameForRead;
   } else {
     return internalError("Unhandled: ${node.runtimeType}");
   }
 }