Add KernelXyzExpression stubs and factory methods.

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, optional;
@@ skipping 646 matching lines @@
     }
     if (optional("&&", token) || optional("||", token)) {
       return doLogicalExpression(token);
     }
     if (optional("??", token)) return doIfNull(token);
     if (optional("?.", token)) return doIfNotNull(token);
     Expression argument = popForValue();
     var receiver = pop();
     bool isSuper = false;
     if (receiver is ThisAccessor && receiver.isSuper) {
+      ThisAccessor thisAccessorReceiver = receiver;
       isSuper = true;
-      receiver = new ThisExpression();
+      receiver = astFactory.thisExpression(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(a, new Name(operator), null, b, offset: token.charOffset);
       if (isSuper) {
         result = toSuperMethodInvocation(result);
       }
-      return negate ? new Not(result) : result;
+      return negate ? astFactory.not(null, result) : result;
     }
   }
 
   void doLogicalExpression(Token token) {
     Expression argument = popForValue();
     Expression receiver = popForValue();
-    push(new LogicalExpression(receiver, token.stringValue, argument));
+    push(astFactory.logicalExpression(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(new VariableGet(variable)), b,
@@ skipping 14 matching lines @@
   }
 
   @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 = new DirectMethodInvocation(
+          Expression result = astFactory.directMethodInvocation(
               new ThisExpression(), target, node.arguments);
-          result = new SuperMethodInvocation(node.name, node.arguments, null);
+          result = astFactory.superMethodInvocation(
+              null, 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 = new DirectPropertyGet(new ThisExpression(), target);
-    receiver = new SuperPropertyGet(node.name, target);
+    Expression receiver =
+        astFactory.directPropertyGet(new ThisExpression(), target);
+    receiver = astFactory.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
@@ skipping 411 matching lines @@
     exitLocalScope();
     push(block);
   }
 
   @override
   void handleAssignmentExpression(Token token) {
     debugEvent("AssignmentExpression");
     Expression value = popForValue();
     var accessor = pop();
     if (accessor is TypeDeclarationBuilder) {
-      push(wrapInvalid(new TypeLiteral(
-          accessor.buildTypesWithBuiltArguments(library, null))));
+      push(wrapInvalid(astFactory
+          .typeLiteral(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 60 matching lines @@
       result = new Block(<Statement>[begin, result]);
     }
     if (breakTarget.hasUsers) {
       result = new LabeledStatement(result);
       breakTarget.resolveBreaks(result);
     }
     exitLoopOrSwitch(result);
   }
 
   @override
-  void endAwaitExpression(Token beginToken, Token endToken) {
+  void endAwaitExpression(Token keyword, Token endToken) {
     debugEvent("AwaitExpression");
-    push(
-        new AwaitExpression(popForValue())..fileOffset = beginToken.charOffset);
+    push(astFactory.awaitExpression(keyword, popForValue()));
   }
 
   @override
   void handleAsyncModifier(Token asyncToken, Token starToken) {
     debugEvent("AsyncModifier");
     push(asyncMarkerFromTokens(asyncToken, starToken));
   }
 
   @override
   void handleLiteralList(
@@ skipping 47 matching lines @@
       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(new MapLiteral(entries,
-        keyType: keyType, valueType: valueType, isConst: constKeyword != null)
-      ..fileOffset = constKeyword?.charOffset ?? beginToken.charOffset);
+    push(astFactory.mapLiteral(beginToken, constKeyword, entries,
+        keyType: keyType, valueType: valueType));
   }
 
   @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(new SymbolLiteral(value));
+    push(astFactory.symbolLiteral(hashToken, value));
   }
 
   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 91 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(new AsExpression(expression, type)..fileOffset = operator.charOffset);
+    push(astFactory.asExpression(expression, operator, type));
   }
 
   @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);
@@ skipping 15 matching lines @@
   }
 
   @override
   void endThrowExpression(Token throwToken, Token endToken) {
     debugEvent("ThrowExpression");
     Expression expression = popForValue();
     if (constantExpressionRequired) {
       push(buildCompileTimeError(
           "Not a constant expression.", throwToken.charOffset));
     } else {
-      push(new Throw(expression)..fileOffset = throwToken.charOffset);
+      push(astFactory.throwExpression(throwToken, expression));
     }
   }
 
   @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) {
@@ skipping 198 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(new Not(toValue(receiver)));
+      push(astFactory.not(token, toValue(receiver)));
     } else {
       String operator = token.stringValue;
       if (optional("-", token)) {
         operator = "unary-";
       }
       if (receiver is ThisAccessor && receiver.isSuper) {
         push(toSuperMethodInvocation(buildMethodInvocation(
-            new ThisExpression()..fileOffset = offsetForToken(receiver.token),
+            astFactory.thisExpression(receiver.token),
             new Name(operator),
             new Arguments.empty(),
             token.charOffset)));
       } else {
         push(buildMethodInvocation(toValue(receiver), new Name(operator),
             new Arguments.empty(), token.charOffset));
       }
     }
   }
 
@@ skipping 87 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 new ConstructorInvocation(target, arguments)
-        ..isConst = isConst
+      return astFactory.constructorInvocation(target, arguments,
+          isConst: isConst)
         ..fileOffset = charOffset;
     } else {
-      return new StaticInvocation(target, arguments)
-        ..isConst = isConst
+      return astFactory.staticInvocation(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 367 matching lines @@
     if (target.continueTarget.hasUsers) {
       if (statement is! LabeledStatement) {
         statement = new LabeledStatement(statement);
       }
       target.continueTarget.resolveContinues(statement);
     }
     push(statement);
   }
 
   @override
-  void endRethrowStatement(Token throwToken, Token endToken) {
+  void endRethrowStatement(Token rethrowToken, Token endToken) {
     debugEvent("RethrowStatement");
     if (inCatchBlock) {
-      push(astFactory.expressionStatement(
-          new Rethrow()..fileOffset = throwToken.charOffset));
+      push(astFactory
+          .expressionStatement(astFactory.rethrowExpression(rethrowToken)));
     } else {
       push(buildCompileTimeErrorStatement(
           "'rethrow' can only be used in catch clauses.",
-          throwToken.charOffset));
+          rethrowToken.charOffset));
     }
   }
 
   @override
   void handleFinallyBlock(Token finallyKeyword) {
     debugEvent("FinallyBlock");
     // Do nothing, handled by [endTryStatement].
   }
 
   @override
@@ skipping 862 matching lines @@
   } else if (node is PrefixBuilder) {
     return node.name;
   } else if (node is ThisAccessor) {
     return node.isSuper ? "super" : "this";
   } else if (node is FastaAccessor) {
     return node.plainNameForRead;
   } else {
     return internalError("Unhandled: ${node.runtimeType}");
   }
 }