Add local type inference logic for integer literals.

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;
 
 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'
     show KernelVariableDeclaration;
 
 import 'package:front_end/src/fasta/type_inference/type_inferrer.dart'
     show TypeInferrer;
 
 import 'package:kernel/ast.dart';
 
 import 'package:kernel/clone.dart' show CloneVisitor;
 
@@ skipping 57 matching lines @@
   final Scope enclosingScope;
 
   final bool isDartLibrary;
 
   @override
   final Uri uri;
 
   final TypeInferrer<Statement, Expression, KernelVariableDeclaration, Field>
       _typeInferrer;
 
+  final AstFactory astFactory;
+
   Scope formalParameterScope;
 
   bool inInitializer = false;
 
   bool inCatchClause = false;
 
   bool inCatchBlock = false;
 
   int functionNestingLevel = 0;
 
@@ skipping 16 matching lines @@
   BodyBuilder(
       KernelLibraryBuilder library,
       this.member,
       Scope scope,
       this.formalParameterScope,
       this.hierarchy,
       this.coreTypes,
       this.classBuilder,
       this.isInstanceMember,
       this.uri,
-      this._typeInferrer)
+      this._typeInferrer,
+      this.astFactory)
       : enclosingScope = scope,
         library = library,
         isDartLibrary = library.uri.scheme == "dart",
         super(scope);
 
   bool get hasParserError => recoverableErrors.isNotEmpty;
 
   bool get inConstructor {
     return functionNestingLevel == 0 && member is KernelConstructorBuilder;
   }
@@ skipping 78 matching lines @@
       var statement = statements[i];
       if (statement is List) {
         copy ??= new List<Statement>.from(statements.getRange(0, i));
         // TODO(sigmund): remove this assignment (issue #28651)
         Iterable subStatements = statement;
         copy.addAll(subStatements);
       } else if (copy != null) {
         copy.add(statement);
       }
     }
-    return new Block(copy ?? statements)..fileOffset = charOffset;
+    return astFactory.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 191 matching lines @@
       if (asyncModifier != AsyncMarker.Sync) {
         // TODO(ahe): Change this to a null check.
         addCompileTimeError(body?.fileOffset,
             "Can't be marked as ${asyncModifier}: ${builder.name}");
       }
     } else if (builder is KernelProcedureBuilder) {
       builder.asyncModifier = asyncModifier;
     } else {
       internalError("Unhandled: ${builder.runtimeType}");
     }
-    _typeInferrer.inferBody(body, uri);
+    _typeInferrer?.inferBody(body, uri);
     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();
         realParameter.initializer = initializer..parent = realParameter;
@@ skipping 464 matching lines @@
           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(astFactory.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) {
@@ skipping 36 matching lines @@
     pushNewLocalVariable(null);
   }
 
   void pushNewLocalVariable(Expression 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,
+    push(astFactory.variableDeclaration(identifier.name,
         initializer: initializer,
-        type: currentLocalVariableType ?? const DynamicType(),
+        type: currentLocalVariableType,
         isFinal: isFinal,
-        isConst: isConst)
-      ..fileEqualsOffset = equalsCharOffset);
+        isConst: isConst,
+        equalsCharOffset: equalsCharOffset));
   }
 
   @override
   void endFieldInitializer(Token assignmentOperator) {
     debugEvent("FieldInitializer");
     assert(assignmentOperator.stringValue == "=");
     push(popForValue());
   }
 
   @override
@@ skipping 433 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 ?? const DynamicType();
-        variable = new VariableDeclaration(name.name,
+        variable = astFactory.variableDeclaration(name.name,
             type: type,
             initializer: name.initializer,
             isFinal: isFinal,
-            isConst: isConst)
-          ..fileOffset = name.fileOffset;
+            isConst: isConst,
+            charOffset: name.fileOffset);
       } else {
         addCompileTimeError(
             name.fileOffset, "'${name.name}' isn't a field in this class.");
       }
     }
-    variable ??= new VariableDeclaration(name.name,
+    variable ??= astFactory.variableDeclaration(name.name,
         type: type ?? const DynamicType(),
         initializer: name.initializer,
         isFinal: isFinal,
-        isConst: isConst)
-      ..fileOffset = name.fileOffset;
+        isConst: isConst,
+        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 438 matching lines @@
     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 =
-        new VariableDeclaration(name.name, isFinal: true);
+        astFactory.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() {
     debugEvent("enterFunction");
@@ skipping 1039 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}");
   }
 }