Setup type and modifiers of local variables on creation.

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;
 
@@ skipping 108 matching lines @@
   Statement compileTimeErrorInTry;
 
   Statement compileTimeErrorInLoopOrSwitch;
 
   Scope switchScope;
 
   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;
+
   BodyBuilder(
       KernelLibraryBuilder library,
       this.member,
       Scope scope,
       this.formalParameterScope,
       this.hierarchy,
       this.coreTypes,
       this.classBuilder,
       this.isInstanceMember,
       this.uri)
@@ skipping 753 matching lines @@
     Statement elsePart = popStatementIfNotNull(elseToken);
     Statement thenPart = popStatement();
     Expression condition = popForValue();
     push(new IfStatement(condition, thenPart, elsePart));
   }
 
   @override
   void endVariableInitializer(Token assignmentOperator) {
     debugEvent("VariableInitializer");
     assert(assignmentOperator.stringValue == "=");
-    Expression initializer = popForValue();
-    Identifier identifier = pop();
-    push(new VariableDeclaration(identifier.name, initializer: initializer)
-      ..fileEqualsOffset = assignmentOperator.charOffset);
+    pushNewLocalVariable(popForValue(),
+        equalsCharOffset: assignmentOperator.charOffset);
   }
 
   @override
   void handleNoVariableInitializer(Token token) {
     debugEvent("NoVariableInitializer");
+    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,
+        initializer: initializer,
+        type: currentLocalVariableType ?? const DynamicType(),
+        isFinal: isFinal,
+        isConst: isConst)..fileEqualsOffset = equalsCharOffset);
   }
 
   @override
   void endFieldInitializer(Token assignmentOperator) {
     debugEvent("FieldInitializer");
     assert(assignmentOperator.stringValue == "=");
     push(popForValue());
   }
 
   @override
   void handleNoFieldInitializer(Token token) {
     debugEvent("NoFieldInitializer");
     push(NullValue.FieldInitializer);
   }
 
   @override
   void endInitializedIdentifier(Token nameToken) {
     // TODO(ahe): Use [InitializedIdentifier] here?
     debugEvent("InitializedIdentifier");
-    TreeNode node = pop();
-    VariableDeclaration variable;
-    if (node is VariableDeclaration) {
-      variable = node;
-    } else if (node is Identifier) {
-      variable = new VariableDeclaration(node.name);
-    } else {
-      internalError("unhandled identifier: ${node.runtimeType}");
-    }
+    VariableDeclaration variable = pop();
     variable.fileOffset = nameToken.charOffset;
     push(variable);
     scope[variable.name] = new KernelVariableBuilder(
         variable, member ?? classBuilder ?? library, uri);
   }
 
   @override
+  void beginVariablesDeclaration(Token token) {
+    debugEvent("beginVariablesDeclaration");
+    DartType type = pop();
+    int modifiers = Modifier.validate(pop());
+    super.push(currentLocalVariableModifiers);
+    super.push(currentLocalVariableType ?? NullValue.Type);
+    currentLocalVariableType = type;
+    currentLocalVariableModifiers = modifiers;
+    super.push(constantExpressionRequired);
+    constantExpressionRequired = (modifiers & constMask) != 0;
+  }
+
+  @override
   void endVariablesDeclaration(int count, Token endToken) {
     debugEvent("VariablesDeclaration");
     List<VariableDeclaration> variables = popList(count);
-    DartType type = pop();
-    int modifiers = Modifier.validate(pop());
-    bool isConst = (modifiers & constMask) != 0;
-    bool isFinal = (modifiers & finalMask) != 0;
-    if (type != null || isConst || isFinal) {
-      type ??= const DynamicType();
-      for (VariableDeclaration variable in variables) {
-        variable
-          ..type = type
-          ..isConst = isConst
-          ..isFinal = isFinal;
-      }
-    }
+    constantExpressionRequired = pop();
+    currentLocalVariableType = pop();
+    currentLocalVariableModifiers = pop();
     if (variables.length != 1) {
       push(variables);
     } else {
       push(variables.single);
     }
   }
 
   @override
   void endBlock(int count, Token beginToken, Token endToken) {
     debugEvent("Block");
@@ skipping 126 matching lines @@
   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);
+    push(new DoubleLiteral(double.parse(token.lexeme))
+      ..fileOffset = token.charOffset);
   }
 
   @override
   void handleLiteralNull(Token token) {
     debugEvent("LiteralNull");
     push(new NullLiteral()..fileOffset = token.charOffset);
   }
 
   @override
   void handleLiteralMap(
@@ skipping 1663 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}");
   }
 }