Fix kernel/visitor_test

pkg/compiler/lib/src/kernel/kernel.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 'dart:async';
 import 'dart:collection' show Queue;
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/checks.dart' show CheckParentPointers;
 
@@ skipping 176 matching lines @@
           isAbstract: cls.isAbstract,
           typeParameters: null,
           implementedTypes: null,
           constructors: null,
           procedures: null,
           fields: null);
       addWork(cls, () {
         if (cls.supertype != null) {
           classNode.supertype = interfaceTypeToIr(cls.supertype);
         }
+        if (cls.isMixinApplication) {
+          MixinApplicationElement mixinApplication = cls;
+          classNode.mixedInType = interfaceTypeToIr(mixinApplication.mixinType);
+        }
         classNode.parent = libraryToIr(cls.library);
         if (cls.isUnnamedMixinApplication) {
           classNode.enclosingLibrary.addClass(classNode);
         }
         cls.implementation
             .forEachMember((ClassElement enclosingClass, Element member) {
           if (member.enclosingClass.declaration != cls) {
             // TODO(het): figure out why impact_test triggers this
             //internalError(cls, "`$member` isn't mine.");
           } else if (member.isFunction ||
               member.isAccessor ||
               member.isConstructor) {
             classNode.addMember(functionToIr(member));
           } else if (member.isField) {
             classNode.addMember(fieldToIr(member));
           } else {
             internalError(member, "Unhandled class member: $member");
           }
         });
         classNode.typeParameters.addAll(typeVariablesToIr(cls.typeVariables));
         for (ir.InterfaceType interface
             in typesToIr(cls.interfaces.reverse().toList())) {
           classNode.implementedTypes.add(interface);
         }
+        addWork(cls, () {
+          addDefaultInstanceFieldInitializers(classNode);
+        });
       });
       addWork(cls.declaration, () {
         for (MetadataAnnotation metadata in cls.declaration.metadata) {
           classNode.addAnnotation(
               const ConstantVisitor().visit(metadata.constant, this));
         }
       });
       return classNode;
     });
   }
 
+  /// Adds initializers to instance fields that are have no initializer and are
+  /// not initialized by all constructors in the class.
+  ///
+  /// This is more or less copied directly from `ast_from_analyzer.dart` in
+  /// dartk.
+  void addDefaultInstanceFieldInitializers(ir.Class node) {
+    List<ir.Field> uninitializedFields = new List<ir.Field>();
+    for (ir.Field field in node.fields) {
+      if (field.initializer != null || field.isStatic) continue;
+      uninitializedFields.add(field);
+    }
+    if (uninitializedFields.isEmpty) return;
+    constructorLoop:
+    for (ir.Constructor constructor in node.constructors) {
+      Set<ir.Field> remainingFields = uninitializedFields.toSet();
+      for (ir.Initializer initializer in constructor.initializers) {
+        if (initializer is ir.FieldInitializer) {
+          remainingFields.remove(initializer.field);
+        } else if (initializer is ir.RedirectingInitializer) {
+          // The target constructor will be checked in another iteration.
+          continue constructorLoop;
+        }
+      }
+      for (ir.Field field in remainingFields) {
+        if (field.initializer == null) {
+          field.initializer = new ir.NullLiteral()..parent = field;
+        }
+      }
+    }
+  }
+
   bool hasHierarchyProblem(ClassElement cls) => cls.hasIncompleteHierarchy;
 
   ir.InterfaceType interfaceTypeToIr(InterfaceType type) {
     ir.Class cls = classToIr(type.element);
     if (type.typeArguments.isEmpty) {
       return cls.rawType;
     } else {
       return new ir.InterfaceType(cls, typesToIr(type.typeArguments));
     }
   }
@@ skipping 210 matching lines @@
       ir.DartType type =
           field.isMalformed ? const ir.InvalidType() : typeToIr(field.type);
       ir.Field fieldNode = new ir.Field(irName(field.memberName.text, field),
           type: type,
           initializer: null,
           isFinal: field.isFinal,
           isStatic: field.isStatic || field.isTopLevel,
           isConst: field.isConst);
       addWork(field, () {
         setParent(fieldNode, field);
-        if (!field.isMalformed && field.initializer != null) {
-          KernelVisitor visitor =
-              new KernelVisitor(field, field.treeElements, this);
-          fieldNode.initializer = visitor.buildInitializer()
-            ..parent = fieldNode;
+        if (!field.isMalformed) {
+          if (field.initializer != null) {
+            KernelVisitor visitor =
+                new KernelVisitor(field, field.treeElements, this);
+            fieldNode.initializer = visitor.buildInitializer()
+              ..parent = fieldNode;
+          } else if (!field.isInstanceMember) {
+            fieldNode.initializer = new ir.NullLiteral()..parent = fieldNode;
+          }
         }
       });
       addWork(field.declaration, () {
         for (MetadataAnnotation metadata in field.declaration.metadata) {
           fieldNode.addAnnotation(
               const ConstantVisitor().visit(metadata.constant, this));
         }
       });
       return fieldNode;
     });
@@ skipping 213 matching lines @@
 }
 
 class ConstructorTarget {
   final ConstructorElement element;
   final DartType type;
 
   ConstructorTarget(this.element, this.type);
 
   String toString() => "ConstructorTarget($element, $type)";
 }