Remove AstFactory from the front end.

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 '../fasta_codes.dart'
     show FastaMessage, codeExpectedButGot, codeExpectedFunctionBody;
 
 import '../parser/parser.dart' show FormalParameterType, MemberKind, optional;
 
 import '../parser/identifier_context.dart' show IdentifierContext;
 
-import 'package:front_end/src/fasta/builder/ast_factory.dart' show AstFactory;
-
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart'

[ahe, 2017/05/24 18:12:57]

FWIW, I think it makes sense to remove the show clause on this import. I know
it's very subjective, so it's up to you.

[Paul Berry, 2017/05/24 18:24:11]

Agreed, it's not adding much value at this point :)

Done.

     show
         KernelArguments,
+        KernelAsExpression,
+        KernelAwaitExpression,
+        KernelBlock,
+        KernelBoolLiteral,
+        KernelConditionalExpression,
+        KernelConstructorInvocation,
+        KernelDirectMethodInvocation,
+        KernelDirectPropertyGet,
+        KernelDoubleLiteral,
+        KernelExpressionStatement,
+        KernelFactoryConstructorInvocation,
         KernelField,
         KernelFunctionDeclaration,
+        KernelFunctionExpression,
+        KernelIfStatement,
+        KernelIntLiteral,
+        KernelIsExpression,
+        KernelIsNotExpression,
+        KernelListLiteral,
+        KernelLogicalExpression,
+        KernelMapLiteral,
+        KernelNot,
+        KernelNullLiteral,
+        KernelRethrow,
         KernelReturnStatement,
+        KernelStaticGet,
+        KernelStaticInvocation,
+        KernelStringConcatenation,
+        KernelStringLiteral,
+        KernelSuperMethodInvocation,
+        KernelSuperPropertyGet,
+        KernelSymbolLiteral,
+        KernelThisExpression,
+        KernelThrow,
+        KernelTypeLiteral,
+        KernelVariableDeclaration,
         KernelYieldStatement;
 
 import 'package:front_end/src/fasta/kernel/utils.dart' show offsetForToken;
 
 import 'package:front_end/src/fasta/type_inference/type_inference_engine.dart'
     show FieldNode;
 
 import 'package:front_end/src/fasta/type_inference/type_inferrer.dart'
     show TypeInferrer;
 
@@ skipping 62 matching lines @@
   final Scope enclosingScope;
 
   final bool isDartLibrary;
 
   @override
   final Uri uri;
 
   final TypeInferrer _typeInferrer;
 
   @override
-  final AstFactory astFactory;
-
-  @override
   final TypePromoter<Expression, VariableDeclaration> typePromoter;
 
   /// If not `null`, dependencies on fields are accumulated into this list.
   ///
   /// If `null`, no dependency information is recorded.
   final List<FieldNode> fieldDependencies;
 
   /// Only used when [member] is a constructor. It tracks if an implicit super
   /// initializer is needed.
   ///
@@ skipping 36 matching lines @@
       KernelLibraryBuilder library,
       this.member,
       Scope scope,
       this.formalParameterScope,
       this.hierarchy,
       this.coreTypes,
       this.classBuilder,
       this.isInstanceMember,
       this.uri,
       this._typeInferrer,
-      this.astFactory,
       {this.fieldDependencies})
       : enclosingScope = scope,
         library = library,
         isDartLibrary = library.uri.scheme == "dart",
         needsImplicitSuperInitializer =
             coreTypes.objectClass != classBuilder?.cls,
         typePromoter = _typeInferrer.typePromoter,
         super(scope);
 
   bool get hasParserError => recoverableErrors.isNotEmpty;
@@ skipping 82 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 astFactory.block(copy ?? statements, beginToken);
+    return new KernelBlock(copy ?? statements)
+      ..fileOffset = offsetForToken(beginToken);
   }
 
   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 212 matching lines @@
     KernelFunctionBuilder builder = member;
     builder.body = body;
     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 ?? astFactory.nullLiteral(null);
+            parameter.initializer ?? new KernelNullLiteral();
         realParameter.initializer = initializer..parent = realParameter;
       }
     }
     if (builder is KernelConstructorBuilder) {
       finishConstructor(builder, asyncModifier);
     } else if (builder is KernelProcedureBuilder) {
       builder.asyncModifier = asyncModifier;
     } else {
       internalError("Unhandled: ${builder.runtimeType}");
     }
@@ skipping 43 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(astFactory.expressionStatement(popForEffect()));
+    push(new KernelExpressionStatement(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) {
         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));
         }
       }
     }
     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(astFactory.arguments(positional, named: named));
+      push(new KernelArguments(positional, named: named));
     } else {
-      push(astFactory.arguments(arguments));
+      push(new KernelArguments(arguments));
     }
   }
 
   @override
   void handleParenthesizedExpression(BeginGroupToken token) {
     debugEvent("ParenthesizedExpression");
     push(new ParenthesizedExpression(this, popForValue(), token.endGroup));
   }
 
   @override
   void endSend(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);
-      astFactory.setExplicitArgumentTypes(arguments, typeArguments);
+      KernelArguments.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 13 matching lines @@
 
     if (receiver is FastaAccessor) {
       if (constantExpressionRequired &&
           !isIdentical(receiver) &&
           !receiver.isInitializer) {
         addCompileTimeError(charOffset, "Not a constant expression.");
       }
       return receiver.doInvocation(charOffset, arguments);
     } else {
       return buildMethodInvocation(
-          astFactory, toValue(receiver), callName, arguments, charOffset);
+          toValue(receiver), callName, arguments, charOffset);
     }
   }
 
   @override
   void beginCascade(Token token) {
     debugEvent("beginCascade");
     Expression expression = popForValue();
     if (expression is CascadeReceiver) {
       push(expression);
       push(new VariableAccessor(this, token, expression.variable));
@@ skipping 25 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 = astFactory.thisExpression(thisAccessorReceiver.token);
+      receiver = new KernelThisExpression()
+        ..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 buildCompileTimeError(
           "Not an operator: '$operator'.", token.charOffset);
     } else {
-      Expression result = makeBinary(astFactory, a, new Name(operator), null, b,
-          offset: token.charOffset);
+      Expression result =
+          makeBinary(a, new Name(operator), null, b, offset: token.charOffset);
       if (isSuper) {
         result = toSuperMethodInvocation(result);
       }
-      return negate ? astFactory.not(null, result) : result;
+      return negate ? new KernelNot(result) : result;
     }
   }
 
   void doLogicalExpression(Token token) {
     Expression argument = popForValue();
     Expression receiver = popForValue();
-    push(astFactory.logicalExpression(receiver, token.stringValue, argument));
+    push(new KernelLogicalExpression(receiver, token.stringValue, argument));
   }
 
   /// Handle `a ?? b`.
   void doIfNull(Token token) {
     Expression b = popForValue();
     Expression a = popForValue();
     VariableDeclaration variable = new VariableDeclaration.forValue(a);
     push(makeLet(
         variable,
-        new ConditionalExpression(
-            buildIsNull(astFactory, new VariableGet(variable)),
-            b,
-            new VariableGet(variable),
-            const DynamicType())));
+        new ConditionalExpression(buildIsNull(new VariableGet(variable)), b,
+            new VariableGet(variable), const DynamicType())));
   }
 
   /// Handle `a?.b(...)`.
   void doIfNotNull(Token token) {
     IncompleteSend send = pop();
     push(send.withReceiver(pop(), isNullAware: true));
   }
 
   void doDotOrCascadeExpression(Token token) {
     // TODO(ahe): Handle null-aware.
     IncompleteSend send = pop();
     Object receiver = optional(".", token) ? pop() : popForValue();
     push(send.withReceiver(receiver));
   }
 
   @override
   Expression toSuperMethodInvocation(MethodInvocation node) {
     Member target = lookupSuperMember(node.name);
     bool isNoSuchMethod = target == null;
     if (target is Procedure) {
       if (!target.isAccessor) {
         if (areArgumentsCompatible(target.function, node.arguments)) {
           // TODO(ahe): Use [DirectMethodInvocation] when possible.
-          Expression result = astFactory.directMethodInvocation(
+          Expression result = new KernelDirectMethodInvocation(
               new ThisExpression(), target, node.arguments);
-          result = astFactory.superMethodInvocation(
-              null, node.name, node.arguments, null);
+          result =
+              new KernelSuperMethodInvocation(node.name, node.arguments, null);
           return result;
         } else {
           isNoSuchMethod = true;
         }
       }
     }
     if (isNoSuchMethod) {
       return throwNoSuchMethodError(
           node.name.name, node.arguments, node.fileOffset,
           isSuper: true);
     }
     // TODO(ahe): Use [DirectPropertyGet] when possible.
     Expression receiver =
-        astFactory.directPropertyGet(new ThisExpression(), target);
-    receiver = astFactory.superPropertyGet(node.name, target);
+        new KernelDirectPropertyGet(new ThisExpression(), target);
+    receiver = new KernelSuperPropertyGet(node.name, target);
     return buildMethodInvocation(
-        astFactory, receiver, callName, node.arguments, node.fileOffset);
+        receiver, callName, node.arguments, node.fileOffset);
   }
 
   bool areArgumentsCompatible(FunctionNode function, Arguments arguments) {
     // TODO(ahe): Implement this.
     return true;
   }
 
   @override
   Expression throwNoSuchMethodError(
       String name, Arguments arguments, int charOffset,
       {bool isSuper: false, isGetter: false, isSetter: false}) {
     String errorName = isSuper ? "super.$name" : name;
     String message;
     if (isGetter) {
       message = "Getter not found: '$errorName'.";
     } else if (isSetter) {
       message = "Setter not found: '$errorName'.";
     } else {
       message = "Method not found: '$errorName'.";
     }
     if (constantExpressionRequired) {
       return buildCompileTimeError(message, charOffset);
     }
     warning(message, charOffset);
     Constructor constructor =
         coreTypes.noSuchMethodErrorClass.constructors.first;
     return new Throw(new ConstructorInvocation(
         constructor,
-        astFactory.arguments(<Expression>[
-          astFactory.nullLiteral(null),
+        new KernelArguments(<Expression>[
+          new KernelNullLiteral(),
           new SymbolLiteral(name),
           new ListLiteral(arguments.positional),
           new MapLiteral(arguments.named.map((arg) {
             return new MapEntry(new SymbolLiteral(arg.name), arg.value);
           }).toList()),
-          astFactory.nullLiteral(null)
+          new KernelNullLiteral()
         ])));
   }
 
   @override
   Member lookupSuperMember(Name name, {bool isSetter: false}) {
     Class superclass = classBuilder.cls.superclass;
     return superclass == null
         ? null
         : hierarchy.getDispatchTarget(superclass, name, setter: isSetter);
   }
@@ skipping 61 matching lines @@
         assert(builder == null);
         if (constantExpressionRequired) {
           return new UnresolvedAccessor(this, n, token);
         }
         return new ThisPropertyAccessor(this, token, n, null, null);
       } else if (isDartLibrary &&
           name == "main" &&
           library.uri.path == "_builtin" &&
           member?.name == "_getMainClosure") {
         // TODO(ahe): https://github.com/dart-lang/sdk/issues/28989
-        return astFactory.nullLiteral(token);
+        return new KernelNullLiteral()..fileOffset = offsetForToken(token);
       } else {
         return new UnresolvedAccessor(this, n, token);
       }
     } else if (builder.isTypeDeclaration) {
       if (constantExpressionRequired &&
           builder.isTypeVariable &&
           !member.isConstructor) {
         addCompileTimeError(
             offsetForToken(token), "Not a constant expression.");
       }
@@ skipping 77 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(astFactory.stringLiteral(value, token));
+      push(new KernelStringLiteral(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(astFactory.stringLiteral(value, first));
+        expressions.add(
+            new KernelStringLiteral(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(astFactory.stringLiteral(value, part));
+            expressions.add(new KernelStringLiteral(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(astFactory.stringLiteral(value, last));
+        expressions.add(
+            new KernelStringLiteral(value)..fileOffset = offsetForToken(last));
       }
-      push(astFactory.stringConcatenation(expressions, endToken));
+      push(new KernelStringConcatenation(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(astFactory.stringConcatenation(expressions ?? parts, null));
+    push(new KernelStringConcatenation(expressions ?? parts));
   }
 
   @override
   void handleLiteralInt(Token token) {
     debugEvent("LiteralInt");
-    push(astFactory.intLiteral(int.parse(token.lexeme), token));
+    push(new KernelIntLiteral(int.parse(token.lexeme))
+      ..fileOffset = offsetForToken(token));
   }
 
   @override
   void handleEmptyFunctionBody(Token semicolon) {
     debugEvent("ExpressionFunctionBody");
     endBlockFunctionBody(0, null, semicolon);
   }
 
   @override
   void handleExpressionFunctionBody(Token arrowToken, Token endToken) {
@@ skipping 28 matching lines @@
     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(astFactory.ifStatement(condition, thenPart, elsePart));
+    push(new KernelIfStatement(condition, thenPart, elsePart));
   }
 
   @override
   void endVariableInitializer(Token assignmentOperator) {
     debugEvent("VariableInitializer");
     assert(assignmentOperator.stringValue == "=");
     pushNewLocalVariable(popForValue(), equalsToken: assignmentOperator);
   }
 
   @override
   void handleNoVariableInitializer(Token token) {
     debugEvent("NoVariableInitializer");
     pushNewLocalVariable(null);
   }
 
   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(astFactory.variableDeclaration(
-        identifier.name, identifier.token, functionNestingLevel,
+    push(new KernelVariableDeclaration(identifier.name, functionNestingLevel,
         initializer: initializer,
         type: currentLocalVariableType,
         isFinal: isFinal,
-        isConst: isConst,
-        equalsToken: equalsToken));
+        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) {
       addCompileTimeError(
           token.charOffset, "const field must have initializer.");
       // Creating a null value to prevent the Dart VM from crashing.
-      push(astFactory.nullLiteral(token));
+      push(new KernelNullLiteral()..fileOffset = offsetForToken(token));
     } else {
       push(NullValue.FieldInitializer);
     }
   }
 
   @override
   void endInitializedIdentifier(Token nameToken) {
     // TODO(ahe): Use [InitializedIdentifier] here?
     debugEvent("InitializedIdentifier");
     VariableDeclaration variable = pop();
@@ skipping 37 matching lines @@
     exitLocalScope();
     push(block);
   }
 
   @override
   void handleAssignmentExpression(Token token) {
     debugEvent("AssignmentExpression");
     Expression value = popForValue();
     var accessor = pop();
     if (accessor is TypeDeclarationBuilder) {
-      push(wrapInvalid(astFactory
-          .typeLiteral(accessor.buildTypesWithBuiltArguments(library, null))));
+      push(wrapInvalid(new KernelTypeLiteral(
+          accessor.buildTypesWithBuiltArguments(library, null))));
     } else if (accessor is! FastaAccessor) {
       push(buildCompileTimeError("Can't assign to this.", token.charOffset));
     } else {
       push(new DelayedAssignment(
           this, token, accessor, value, token.stringValue));
     }
   }
 
   @override
   void enterLoop(int charOffset) {
@@ skipping 37 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 = astFactory.expressionStatement(variableOrExpression);
+      begin = new KernelExpressionStatement(variableOrExpression);
     } else {
       return internalError("Unhandled: ${variableOrExpression.runtimeType}");
     }
     exitLocalScope();
     JumpTarget continueTarget = exitContinueTarget();
     JumpTarget breakTarget = exitBreakTarget();
     if (continueTarget.hasUsers) {
       body = new LabeledStatement(body);
       continueTarget.resolveContinues(body);
     }
     Statement result = new ForStatement(variables, condition, updates, body);
     if (begin != null) {
       result = new Block(<Statement>[begin, result]);
     }
     if (breakTarget.hasUsers) {
       result = new LabeledStatement(result);
       breakTarget.resolveBreaks(result);
     }
     exitLoopOrSwitch(result);
   }
 
   @override
   void endAwaitExpression(Token keyword, Token endToken) {
     debugEvent("AwaitExpression");
-    push(astFactory.awaitExpression(keyword, popForValue()));
+    push(new KernelAwaitExpression(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(
             "Too many type arguments on List literal.", beginToken.charOffset);
       }
     }
-    push(astFactory.listLiteral(expressions, typeArgument, constKeyword != null,
-        constKeyword ?? beginToken));
+    push(new KernelListLiteral(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(astFactory.boolLiteral(value, token));
+    push(new KernelBoolLiteral(value)..fileOffset = offsetForToken(token));
   }
 
   @override
   void handleLiteralDouble(Token token) {
     debugEvent("LiteralDouble");
-    push(astFactory.doubleLiteral(double.parse(token.lexeme), token));
+    push(new KernelDoubleLiteral(double.parse(token.lexeme))
+      ..fileOffset = offsetForToken(token));
   }
 
   @override
   void handleLiteralNull(Token token) {
     debugEvent("LiteralNull");
-    push(astFactory.nullLiteral(token));
+    push(new KernelNullLiteral()..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 = const DynamicType();
     DartType valueType = const DynamicType();
     if (typeArguments != null) {
       if (typeArguments.length != 2) {
         keyType = const DynamicType();
         valueType = const DynamicType();
         warningNotError(
             "Map literal requires two type arguments.", beginToken.charOffset);
       } else {
         keyType = typeArguments[0];
         valueType = typeArguments[1];
       }
     }
-    push(astFactory.mapLiteral(beginToken, constKeyword, entries,
-        keyType: keyType, valueType: valueType));
+    push(new KernelMapLiteral(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 13 matching lines @@
     String value;
     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(astFactory.symbolLiteral(hashToken, value));
+    push(
+        new KernelSymbolLiteral(value)..fileOffset = offsetForToken(hashToken));
   }
 
   DartType kernelTypeFromString(
       String name, List<DartType> arguments, int charOffset) {
     Builder builder = scope.lookup(name, charOffset, uri);
     if (builder == null) {
       warning("Type not found: '$name'.", charOffset);
       return const DynamicType();
     } else {
       return kernelTypeFromBuilder(builder, arguments, charOffset);
@@ skipping 100 matching lines @@
   void handleVoidKeyword(Token token) {
     debugEvent("VoidKeyword");
     push(const VoidType());
   }
 
   @override
   void handleAsOperator(Token operator, Token endToken) {
     debugEvent("AsOperator");
     DartType type = pop();
     Expression expression = popForValue();
-    push(astFactory.asExpression(expression, operator, type));
+    push(new KernelAsExpression(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;
-    Expression isExpression =
-        astFactory.isExpression(operand, type, operator, isInverted);
+    var offset = offsetForToken(operator);
+    Expression isExpression = isInverted
+        ? new KernelIsNotExpression(operand, type, offset)
+        : new KernelIsExpression(operand, type)
+      ..fileOffset = offset;
     if (operand is VariableGet) {
       typePromoter.handleIsCheck(isExpression, isInverted, operand.variable,
           type, functionNestingLevel);
     }
     push(isExpression);
   }
 
   @override
   void handleConditionalExpression(Token question, Token colon) {
     debugEvent("ConditionalExpression");
     Expression elseExpression = popForValue();
     Expression thenExpression = popForValue();
     Expression condition = popForValue();
-    push(astFactory.conditionalExpression(
+    push(new KernelConditionalExpression(
         condition, thenExpression, elseExpression));
   }
 
   @override
   void endThrowExpression(Token throwToken, Token endToken) {
     debugEvent("ThrowExpression");
     Expression expression = popForValue();
     if (constantExpressionRequired) {
       push(buildCompileTimeError(
           "Not a constant expression.", throwToken.charOffset));
     } else {
-      push(astFactory.throwExpression(throwToken, expression));
+      push(
+          new KernelThrow(expression)..fileOffset = offsetForToken(throwToken));
     }
   }
 
   @override
   void endFormalParameter(Token thisKeyword, Token nameToken,
       FormalParameterType kind, MemberKind memberKind) {
     debugEvent("FormalParameter");
     if (thisKeyword != null) {
       if (!inConstructor) {
         addCompileTimeError(thisKeyword.charOffset,
@@ skipping 27 matching lines @@
       } else if (thisKeyword == null) {
         variable = builder.build(library);
         variable.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;
-        variable = astFactory.variableDeclaration(
-            name.name, name.token, functionNestingLevel,
+        variable = new KernelVariableDeclaration(
+            name.name, functionNestingLevel,
             type: type,
             initializer: name.initializer,
             isFinal: isFinal,
-            isConst: isConst);
+            isConst: isConst)
+          ..fileOffset = offsetForToken(name.token);
       } else {
         addCompileTimeError(offsetForToken(name.token),
             "'${name.name}' isn't a field in this class.");
       }
     }
-    variable ??= astFactory.variableDeclaration(
-        name?.name, name?.token, functionNestingLevel,
+    variable ??= new KernelVariableDeclaration(name?.name, functionNestingLevel,
         type: type,
         initializer: name?.initializer,
         isFinal: isFinal,
-        isConst: isConst);
+        isConst: isConst)
+      ..fileOffset = offsetForToken(name?.token);
     push(variable);
   }
 
   @override
   void endOptionalFormalParameters(
       int count, Token beginToken, Token endToken) {
     debugEvent("OptionalFormalParameters");
     FormalParameterType kind = optional("{", beginToken)
         ? FormalParameterType.NAMED
         : FormalParameterType.POSITIONAL;
@@ skipping 137 matching lines @@
       push(IndexAccessor.make(
           this, openCurlyBracket, toValue(receiver), index, null, null));
     }
   }
 
   @override
   void handleUnaryPrefixExpression(Token token) {
     debugEvent("UnaryPrefixExpression");
     var receiver = pop();
     if (optional("!", token)) {
-      push(astFactory.not(token, toValue(receiver)));
+      push(
+          new KernelNot(toValue(receiver))..fileOffset = offsetForToken(token));
     } else {
       String operator = token.stringValue;
       if (optional("-", token)) {
         operator = "unary-";
       }
       if (receiver is ThisAccessor && receiver.isSuper) {
         push(toSuperMethodInvocation(buildMethodInvocation(
-            astFactory,
-            astFactory.thisExpression(receiver.token),
+            new KernelThisExpression()
+              ..fileOffset = offsetForToken(receiver.token),
             new Name(operator),
             new Arguments.empty(),
             token.charOffset)));
       } else {
-        push(buildMethodInvocation(astFactory, toValue(receiver),
-            new Name(operator), new Arguments.empty(), token.charOffset));
+        push(buildMethodInvocation(toValue(receiver), 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}");
   }
 
@@ skipping 81 matching lines @@
       {bool isConst: false, int charOffset: -1}) {
     List<TypeParameter> typeParameters = target.function.typeParameters;
     if (target is Constructor) {
       assert(!target.enclosingClass.isAbstract);
       typeParameters = target.enclosingClass.typeParameters;
     }
     if (!checkArguments(target.function, arguments, typeParameters)) {
       return throwNoSuchMethodError(target.name.name, arguments, charOffset);
     }
     if (target is Constructor) {
-      return astFactory.constructorInvocation(target, arguments,
+      return new KernelConstructorInvocation(target, arguments,
+          isConst: isConst)
+        ..fileOffset = charOffset;
+    } else if (target is Procedure && target.kind == ProcedureKind.Factory) {
+      return new KernelFactoryConstructorInvocation(target, arguments,
           isConst: isConst)
         ..fileOffset = charOffset;
     } else {
-      return astFactory.staticInvocation(target, arguments, isConst: isConst)
+      return new KernelStaticInvocation(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) {
       return false;
@@ skipping 66 matching lines @@
     var type = pop();
     bool savedConstantExpressionRequired = pop();
     () {
       if (arguments == null) {
         push(buildCompileTimeError("No arguments.", nameToken.charOffset));
         return;
       }
 
       if (typeArguments != null) {
         assert(arguments.types.isEmpty);
-        astFactory.setExplicitArgumentTypes(arguments, typeArguments);
+        KernelArguments.setExplicitArgumentTypes(arguments, typeArguments);
       }
 
       String errorName;
       if (type is ClassBuilder) {
         Builder b = type.findConstructorOrFactory(name, token.charOffset, uri);
         Member target;
         if (b == null) {
           // Not found. Reported below.
         } else if (b.isConstructor) {
           if (type.isAbstract) {
@@ skipping 73 matching lines @@
     debugEvent("NamedArgument");
     Expression value = popForValue();
     Identifier identifier = pop();
     push(new NamedExpression(identifier.name, value));
   }
 
   @override
   void endFunctionName(Token beginToken, Token token) {
     debugEvent("FunctionName");
     Identifier name = pop();
-    VariableDeclaration variable = astFactory.variableDeclaration(
-        name.name, name.token, functionNestingLevel,
-        isFinal: true, isLocalFunction: true);
+    VariableDeclaration variable = new KernelVariableDeclaration(
+        name.name, functionNestingLevel,
+        isFinal: true, isLocalFunction: true)
+      ..fileOffset = offsetForToken(name.token);
     push(new KernelFunctionDeclaration(
         variable, new FunctionNode(new InvalidStatement()))
       ..fileOffset = beginToken.charOffset);
     declareVariable(variable);
     enterLocalScope();
   }
 
   void enterFunction() {
     debugEvent("enterFunction");
     functionNestingLevel++;
@@ skipping 59 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(astFactory.functionExpression(function, beginToken));
+    push(new KernelFunctionExpression(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();
@@ skipping 45 matching lines @@
       ///     for (lvalue in expression) body
       ///
       /// This is normalized to:
       ///
       ///     for (final #t in expression) {
       ///       lvalue = #t;
       ///       body;
       ///     }
       variable = new VariableDeclaration.forValue(null);
       body = combineStatements(
-          astFactory.expressionStatement(lvalue
+          new KernelExpressionStatement(lvalue
               .buildAssignment(new VariableGet(variable), voidContext: true)),
           body);
     } else {
       variable = new VariableDeclaration.forValue(buildCompileTimeError(
           "Expected lvalue, but got ${lvalue}", forToken.next.next.charOffset));
     }
     Statement result = new ForInStatement(variable, expression, body,
         isAsync: awaitToken != null)
       ..fileOffset = body.fileOffset;
     if (breakTarget.hasUsers) {
@@ skipping 41 matching lines @@
       }
       target.continueTarget.resolveContinues(statement);
     }
     push(statement);
   }
 
   @override
   void endRethrowStatement(Token rethrowToken, Token endToken) {
     debugEvent("RethrowStatement");
     if (inCatchBlock) {
-      push(astFactory
-          .expressionStatement(astFactory.rethrowExpression(rethrowToken)));
+      push(new KernelExpressionStatement(
+          new KernelRethrow()..fileOffset = offsetForToken(rethrowToken)));
     } else {
       push(buildCompileTimeErrorStatement(
           "'rethrow' can only be used in catch clauses.",
           rethrowToken.charOffset));
     }
   }
 
   @override
   void handleFinallyBlock(Token finallyKeyword) {
     debugEvent("FinallyBlock");
@@ skipping 273 matching lines @@
     }
     return super.handleUnrecoverableError(token, message);
   }
 
   @override
   Expression 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,
-        astFactory.arguments(<Expression>[new StringLiteral(message)])));
+        new KernelArguments(<Expression>[new StringLiteral(message)])));
   }
 
   Expression buildAbstractClassInstantiationError(String className,
       [int charOffset = -1]) {
     warning("The class '$className' is abstract and can't be instantiated.",
         charOffset);
     Builder constructor = library.loader.getAbstractClassInstantiationError();
     return new Throw(buildStaticInvocation(constructor.target,
-        astFactory.arguments(<Expression>[new StringLiteral(className)])));
+        new KernelArguments(<Expression>[new StringLiteral(className)])));
   }
 
   Statement buildCompileTimeErrorStatement(error, [int charOffset = -1]) {
-    return astFactory
-        .expressionStatement(buildCompileTimeError(error, charOffset));
+    return new KernelExpressionStatement(
+        buildCompileTimeError(error, charOffset));
   }
 
   @override
   Initializer buildInvalidIntializer(Expression expression,
       [int charOffset = -1]) {
     needsImplicitSuperInitializer = false;
     return new LocalInitializer(new VariableDeclaration.forValue(expression))
       ..fileOffset = charOffset;
   }
 
@@ skipping 91 matching lines @@
   @override
   StaticGet makeStaticGet(Member readTarget, Token token) {
     // TODO(paulberry): only record the dependencies mandated by the top level
     // type inference spec.
     if (fieldDependencies != null && readTarget is KernelField) {
       var fieldNode = _typeInferrer.getFieldNodeForReadTarget(readTarget);
       if (fieldNode != null) {
         fieldDependencies.add(fieldNode);
       }
     }
-    return astFactory.staticGet(readTarget, token);
+    return new KernelStaticGet(readTarget)..fileOffset = offsetForToken(token);
   }
 }
 
 class Identifier {
   final Token token;
   String get name => token.lexeme;
 
   Identifier(this.token);
 
   Expression get initializer => null;
@@ skipping 471 matching lines @@
     if (starToken == null) {
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return internalError("Unknown async modifier: $asyncToken");
   }
 }