Revert "Add null initializers to fields that have no initializer."

lib/analyzer/ast_from_analyzer.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 kernel.analyzer.ast_from_analyzer;
 
 import '../ast.dart' as ast;
 import '../frontend/accessors.dart';
 import '../frontend/super_initializers.dart';
 import '../log.dart';
 import '../type_algebra.dart';
@@ skipping 2322 matching lines @@
         assert(defaultConstructor.enclosingElement == node.element);
         if (!defaultConstructor.isSynthetic) {
           throw 'Non-synthetic default constructor not in list of members. '
               '${node} $element $defaultConstructor';
         }
         var memberNode = scope.getMemberReference(defaultConstructor);
         classNode.addMember(memberNode);
         buildDefaultConstructor(memberNode, defaultConstructor);
       }
     }
-
-    addDefaultFieldInitializers(classNode);
   }
 
   void buildDefaultConstructor(
       ast.Constructor constructor, ConstructorElement element) {
     var function = constructor.function;
     function.body = new ast.EmptyStatement()..parent = function;
     var class_ = element.enclosingElement;
     if (class_.supertype != null) {
       // DESIGN TODO: If the super class is a mixin application, we will link to
       // a constructor not in the immediate super class.  This is a problem due
       // to the fact that mixed-in fields come with initializers which need to
       // be executed by a constructor.  The mixin transformer takes care of
       // this by making forwarding constructors and the super initializers will
       // be rewritten to use them (see `transformations/mixin_full_resolution`).
       var superConstructor =
           scope.findDefaultConstructor(class_.supertype.element);
       var target = scope.resolveConstructor(superConstructor);
       if (target == null) {
         constructor.initializers
             .add(new ast.InvalidInitializer()..parent = constructor);
       } else {
         var arguments = new ast.Arguments.empty();
         constructor.initializers.add(
             new ast.SuperInitializer(target, arguments)..parent = constructor);
       }
     }
   }
 
-  /// Adds initializers to fields that are have no initializer and are not
-  /// initialized by all constructors in the class.
-  void addDefaultFieldInitializers(ast.Class node) {
-    List<ast.Field> uninitializedFields = new List<ast.Field>();
-    for (var field in node.fields) {
-      if (field.initializer != null || field.isExternal) continue;
-      if (field.isStatic) {
-        field.initializer = new ast.NullLiteral()..parent = field;
-      } else {
-        uninitializedFields.add(field);
-      }
-    }
-    if (uninitializedFields.isEmpty) return;
-    constructorLoop:
-    for (var constructor in node.constructors) {
-      var remainingFields = uninitializedFields.toSet();
-      for (var initializer in constructor.initializers) {
-        if (initializer is ast.FieldInitializer) {
-          remainingFields.remove(initializer.field);
-        } else if (initializer is ast.RedirectingInitializer) {
-          // The target constructor will be checked in another iteration.
-          continue constructorLoop;
-        }
-      }
-      for (var field in remainingFields) {
-        if (field.initializer == null) {
-          field.initializer = new ast.NullLiteral()..parent = field;
-        }
-      }
-    }
-  }
-
   /// True for the `values` field of an `enum` class.
   static bool _isValuesField(FieldElement field) => field.name == 'values';
 
   /// True for the `index` field of an `enum` class.
   static bool _isIndexField(FieldElement field) => field.name == 'index';
 
   visitEnumDeclaration(EnumDeclaration node) {
     addAnnotations(node.metadata);
     ast.Class classNode = currentClass;
     var intType =
@@ skipping 341 matching lines @@
   if (element is FieldElement) return element.getter;
   return element;
 }
 
 Element desynthesizeSetter(Element element) {
   if (element == null || !element.isSynthetic) return element;
   if (element is PropertyAccessorElement) return element.variable;
   if (element is FieldElement) return element.setter;
   return element;
 }