When reordering constructor initializers, use correct types for temp vars.

pkg/front_end/lib/src/fasta/kernel/kernel_procedure_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.kernel_procedure_builder;
 
+import 'package:front_end/src/fasta/type_inference/type_inferrer.dart'
+    show TypeInferrer;
+
 import 'package:kernel/ast.dart'
     show
         Arguments,
         AsyncMarker,
         Constructor,
         ConstructorInvocation,
         DartType,
         DynamicType,
         EmptyStatement,
         Expression,
@@ skipping 365 matching lines @@
 
   Constructor get target => constructor;
 
   void checkSuperOrThisInitializer(Initializer initializer) {
     if (superInitializer != null || redirectingInitializer != null) {
       return deprecated_inputError(fileUri, initializer.fileOffset,
           "Can't have more than one 'super' or 'this' initializer.");
     }
   }
 
-  void addInitializer(Initializer initializer) {
+  void addInitializer(Initializer initializer, TypeInferrer typeInferrer) {
     List<Initializer> initializers = constructor.initializers;
     if (initializer is SuperInitializer) {
       checkSuperOrThisInitializer(initializer);
       superInitializer = initializer;
     } else if (initializer is RedirectingInitializer) {
       checkSuperOrThisInitializer(initializer);
       redirectingInitializer = initializer;
       if (constructor.initializers.isNotEmpty) {
         deprecated_inputError(fileUri, initializer.fileOffset,
             "'this' initializer must be the only initializer.");
@@ skipping 10 matching lines @@
       initializers.removeLast();
       if (!hasMovedSuperInitializer) {
         // To preserve correct evaluation order, the arguments to super call
         // must be evaluated before [initializer]. Once the super initializer
         // has been moved once, the arguments are evaluated in the correct
         // order.
         hasMovedSuperInitializer = true;
         Arguments arguments = superInitializer.arguments;
         List<Expression> positional = arguments.positional;
         for (int i = 0; i < positional.length; i++) {
-          VariableDeclaration variable =
-              new VariableDeclaration.forValue(positional[i], isFinal: true);
+          var type = typeInferrer.typeSchemaEnvironment.strongMode

[ahe, 2017/08/08 13:31:18]

Missing type on variable.

[Paul Berry, 2017/08/08 16:42:25]

IMHO this is ok--type inference will infer DartType, and anyone familiar with
the code will know this is a DartType as well.

[ahe, 2017/08/08 17:35:44]

I wouldn't have complained if hadn't used a type on line 429, but in this case,
the lack of type caused me to stumble when reading this. I had to scan two lines
ahead to figure out that this was probably DartType (based on const
DynamicType).

+              ? positional[i].getStaticType(typeInferrer.typeSchemaEnvironment)
+              : const DynamicType();
+          VariableDeclaration variable = new VariableDeclaration.forValue(
+              positional[i],
+              isFinal: true,
+              type: type);
           initializers
               .add(new LocalInitializer(variable)..parent = constructor);
           positional[i] = new VariableGet(variable)..parent = arguments;
         }
         for (NamedExpression named in arguments.named) {
           VariableDeclaration variable =
               new VariableDeclaration.forValue(named.value, isFinal: true);
           named.value = new VariableGet(variable)..parent = named;
           initializers
               .add(new LocalInitializer(variable)..parent = constructor);
         }
       }
       initializers.add(initializer..parent = constructor);
       initializers.add(superInitializer);
       return;
     }
     initializers.add(initializer);
     initializer.parent = constructor;
   }
 }