Roll kernel to latest and add baseline test.

pkg/compiler/lib/src/kernel/kernel_visitor.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.md file.
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/frontend/accessors.dart'
     show
         Accessor,
         IndexAccessor,
         NullAwarePropertyAccessor,
         PropertyAccessor,
         ReadOnlyAccessor,
         StaticAccessor,
         SuperIndexAccessor,
         SuperPropertyAccessor,
         ThisPropertyAccessor,
         VariableAccessor,
         buildIsNull,
         makeBinary,
         makeLet,
         makeOrReuseVariable;
 
+import '../common.dart';
 import '../constants/expressions.dart'
     show
         BoolFromEnvironmentConstantExpression,
         ConstantExpression,
         ConstructedConstantExpression,
         IntFromEnvironmentConstantExpression,
         StringFromEnvironmentConstantExpression,
         TypeConstantExpression;
 import '../dart_types.dart' show DartType, InterfaceType;
 import '../diagnostics/spannable.dart' show Spannable;
@@ skipping 1343 matching lines @@
     return buildStaticFieldSet(field, rhs);
   }
 
   @override
   ir.Expression visitFinalSuperFieldSet(
       SendSet node, FieldElement field, Node rhs, _) {
     return buildSuperPropertyAccessor(field)
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
-  void addFieldsWithInitializers(
-      ConstructorElement constructor, List<ir.Initializer> initializers) {
-    constructor.enclosingClass.forEachInstanceField((_, FieldElement element) {
-      // Convert the element into the corresponding IR field before asking
-      // if the initializer exists. This is necessary to ensure that the
-      // element has been analyzed before looking at its initializer.
-      ir.Field field = kernel.fieldToIr(element);
-      if (element.initializer != null) {
-        KernelVisitor visitor =
-            new KernelVisitor(element, element.treeElements, kernel);
-        ir.Expression value = visitor.buildInitializer();
-        initializers.add(new ir.FieldInitializer(field, value));
-      }
-    });
-  }
-
   IrFunction buildGenerativeConstructor(
       ConstructorElement constructor, NodeList parameters, Node body) {
     List<ir.Initializer> constructorInitializers = <ir.Initializer>[];
     if (kernel.hasHierarchyProblem(constructor.enclosingClass)) {
       constructorInitializers.add(new ir.InvalidInitializer());
     } else if (constructor.isSynthesized) {
       List<ir.Expression> arguments = const <ir.Expression>[];
       List<ir.NamedExpression> named = const <ir.NamedExpression>[];
       FunctionSignature signature = constructor.functionSignature;
       if (signature.parameterCount != 0) {
         // Mixin application implicit super call.
         arguments = <ir.Expression>[];
         named = <ir.NamedExpression>[];
         signature.orderedForEachParameter((ParameterElement parameter) {
           ir.VariableGet argument = buildLocalGet(parameter);
           if (parameter.isNamed) {
             named.add(new ir.NamedExpression(parameter.name, argument));
           } else {
             arguments.add(argument);
           }
         });
       }
       if (kernel.isSyntheticError(constructor.definingConstructor)) {
         constructorInitializers.add(new ir.InvalidInitializer());
       } else {
-        addFieldsWithInitializers(constructor, constructorInitializers);
         constructorInitializers.add(new ir.SuperInitializer(
             kernel.functionToIr(constructor.definingConstructor),
             new ir.Arguments(arguments, named: named, types: null)));
       }
     } else {
-      addFieldsWithInitializers(constructor, constructorInitializers);
       if (parameters != null) {
         // TODO(ahe): the following is a (modified) copy of
         // [SemanticDeclarationResolvedMixin.visitParameters].
         List<ParameterStructure> structures =
             computeParameterStructures(parameters);
         for (ParameterStructure structure in structures) {
           if (structure.parameter.isInitializingFormal) {
             constructorInitializers.add(structure.dispatch(declVisitor, null));
           }
         }
@@ skipping 508 matching lines @@
     if (setterKind == CompoundSetter.INVALID) {
       setter = null;
     }
     return buildStaticAccessor(getter, setter).buildNullAwareAssignment(
         visitForValue(rhs),
         voidContext: isVoidContext);
   }
 
   ir.VariableDeclaration getLocal(LocalElement local) {
     return locals.putIfAbsent(local, () {
+      // Currently, initializing formals are not final.
+      bool isFinal = local.isFinal && !local.isInitializingFormal;
       return associateElement(
           new ir.VariableDeclaration(local.name,
               initializer: null,
               type: typeToIrHack(local.type),
-              isFinal: local.isFinal,
+              isFinal: isFinal,
               isConst: local.isConst),
           local);
     });
   }
 
   ir.FunctionNode buildFunctionNode(FunctionElement function, Node bodyNode) {
     List<ir.TypeParameter> typeParameters =
         kernel.typeParametersNotImplemented();
     List<ir.VariableDeclaration> positionalParameters =
         <ir.VariableDeclaration>[];
@@ skipping 13 matching lines @@
       });
       signature.forEachParameter((ParameterElement parameter) {
         if (!parameter.isOptional) return;
         ir.Expression initializer = visitForValue(parameter.initializer);
         ir.VariableDeclaration variable = getLocal(parameter);
         if (initializer != null) {
           variable.initializer = initializer;
           initializer.parent = variable;
         }
       });
-      returnType = typeToIrHack(signature.type.returnType);
+      if (function.isGenerativeConstructor) {
+        returnType = const ir.VoidType();
+      } else {
+        returnType = typeToIrHack(signature.type.returnType);
+      }
       if (function.isFactoryConstructor) {
         InterfaceType type = function.enclosingClass.thisType;
         if (type.isGeneric) {
           typeParameters = new List<ir.TypeParameter>();
           for (DartType parameter in type.typeArguments) {
             typeParameters.add(kernel.typeVariableToIr(parameter.element));
           }
         }
       }
     }
@@ skipping 15 matching lines @@
         case AsyncMarker.ASYNC_STAR:
           asyncMarker = ir.AsyncMarker.AsyncStar;
           break;
 
         default:
           internalError(
               function, "Unknown async maker: ${function.asyncMarker}");
           break;
       }
     }
-    ir.Statement body =
-        (bodyNode == null) ? null : buildStatementInBlock(bodyNode);
+    ir.Statement body;
+    if (function.isExternal) {
+      // [body] must be `null`.
+    } else if (function.isConstructor) {
+      // TODO(johnniwinther): Clean this up pending kernel issue #28.
+      ConstructorElement constructor = function;
+      if (constructor.isDefaultConstructor) {
+        body = new ir.EmptyStatement();
+      } else if (bodyNode != null && bodyNode.asEmptyStatement() == null) {
+        body = buildStatementInBlock(bodyNode);
+      }
+    } else if (bodyNode != null) {
+      body = buildStatementInBlock(bodyNode);
+    }
     return associateElement(
         new ir.FunctionNode(body,
             asyncMarker: asyncMarker,
             returnType: returnType,
             typeParameters: typeParameters,
             positionalParameters: positionalParameters,
             namedParameters: namedParameters,
             requiredParameterCount: requiredParameterCount),
         function);
   }
@@ skipping 708 matching lines @@
       : this(null, true, node, initializers);
 
   accept(ir.Visitor v) => throw "unsupported";
 
   visitChildren(ir.Visitor v) => throw "unsupported";
 
   String toString() {
     return "IrFunction($kind, $isConstructor, $node, $initializers)";
   }
 }