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 = const DynamicType();
+
+  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();
+    bool isConst = (currentLocalVariableModifiers & constMask) != 0;

[karlklose, 2017/03/23 09:52:15]

assert(currentLocalVariableModifiers != -1) here?

[ahe, 2017/03/23 11:17:54]

Done.

+    bool isFinal = (currentLocalVariableModifiers & finalMask) != 0;
+    assert(isConst == constantExpressionRequired);
+    push(new VariableDeclaration(identifier.name,
+        initializer: initializer,
+        type: currentLocalVariableType,
+        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);

[Paul Berry, 2017/03/23 10:50:52]

Why not:

push(currentLocalVariableModifiers ?? NullValue.LocalVariableModifiers);

(and add `LocalVariableModifiers` to the `NullValue` enum)

[ahe, 2017/03/23 11:17:55]

I need to use super.push to avoid changing inInitializer. I'll look into
cleaning that up.

Based on some old advice regarding performance, I'm avoiding initializing an int
field to null, hence currentLocalVariableModifiers can't be null.

+    super.push(currentLocalVariableType);

[Paul Berry, 2017/03/23 10:50:52]

Similar question here.

[ahe, 2017/03/23 11:17:55]

I'll change it to ?? NullValue.Type.

+    currentLocalVariableType = type ?? const DynamicType();

[Paul Berry, 2017/03/23 10:50:52]

FYI, for type inference we will need to keep track of whether an explicit type
was provided, so consider moving the `?? const DynamicType()` to line 924.

[ahe, 2017/03/23 11:17:54]

Done.

+    currentLocalVariableModifiers = modifiers;
+    super.push(constantExpressionRequired);

[Paul Berry, 2017/03/23 10:50:52]

AFAICT, `constantExpressionRequired` is never null, so I think we can do:

push(constantExpressionRequired)

[ahe, 2017/03/23 11:17:54]

As mentioned above, super.push is used to avoid interfering with inInitializer.

+    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 1810 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}");
   }
 }