Create NullLiteral using AstFactory in BodyBuilder.

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 456 matching lines @@
     _typeInferrer.inferStatement(body);
     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 ?? new NullLiteral();
+        Expression initializer =
+            parameter.initializer ?? astFactory.nullLiteral(null);
         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 282 matching lines @@
     }
     if (constantExpressionRequired) {
       return buildCompileTimeError(message, charOffset);
     }
     warning(message, charOffset);
     Constructor constructor =
         coreTypes.getClass("dart:core", "NoSuchMethodError").constructors.first;
     return new Throw(new ConstructorInvocation(
         constructor,
         new Arguments(<Expression>[
-          new NullLiteral(),
+          astFactory.nullLiteral(null),
           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()
+          astFactory.nullLiteral(null)
         ])));
   }
 
   @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 new NullLiteral()..fileOffset = offsetForToken(token);
+        return astFactory.nullLiteral(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 232 matching lines @@
     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(new NullLiteral()..fileOffset = token.charOffset);
+      push(astFactory.nullLiteral(token));
     } else {
       push(NullValue.FieldInitializer);
     }
   }
 
   @override
   void endInitializedIdentifier(Token nameToken) {
     // TODO(ahe): Use [InitializedIdentifier] here?
     debugEvent("InitializedIdentifier");
     VariableDeclaration variable = pop();
@@ skipping 169 matching lines @@
 
   @override
   void handleLiteralDouble(Token token) {
     debugEvent("LiteralDouble");
     push(astFactory.doubleLiteral(double.parse(token.lexeme), token));
   }
 
   @override
   void handleLiteralNull(Token token) {
     debugEvent("LiteralNull");
-    push(new NullLiteral()..fileOffset = token.charOffset);
+    push(astFactory.nullLiteral(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();
@@ skipping 1804 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}");
   }
 }