Revert "Fix some crashes in dartk."

pkg/kernel/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 736 matching lines @@
   }
 
   ast.Expression buildThrowCompileTimeError(String message) {
     // The spec does not mandate a specific behavior in face of a compile-time
     // error.  We just throw a string.  The VM throws an uncatchable exception
     // for this case.
     // TOOD(asgerf): Should we add uncatchable exceptions to kernel?
     return new ast.Throw(new ast.StringLiteral(message));
   }
 
-  ast.Expression buildThrowCompileTimeErrorFromCode(ErrorCode code,
-      [List arguments]) {
-    return buildThrowCompileTimeError(makeErrorMessage(code, arguments));
-  }
-
   static final RegExp _errorMessagePattern = new RegExp(r'\{(\d+)\}');
 
-  String makeErrorMessage(ErrorCode error, [List arguments]) {
+  /// Throws an exception that will be caught at the function level, to replace
+  /// the entire function with a throw.
+  emitCompileTimeError(ErrorCode error, [List arguments]) {
     String message = error.message;
     if (arguments != null) {
       message = message.replaceAllMapped(_errorMessagePattern, (m) {
         String numberString = m.group(1);
         int index = int.parse(numberString);
         return arguments[index];
       });
     }
-    return message;
-  }
-
-  /// Throws an exception that will be caught at the function level, to replace
-  /// the entire function with a throw.
-  emitCompileTimeError(ErrorCode error, [List arguments]) {
-    throw new _CompilationError(makeErrorMessage(error, arguments));
+    throw new _CompilationError(message);
   }
 
   ast.Expression buildThrowAbstractClassInstantiationError(String name) {
     return new ast.Throw(new ast.ConstructorInvocation(
         loader.getCoreClassConstructorReference(
             'AbstractClassInstantiationError'),
         new ast.Arguments(<ast.Expression>[new ast.StringLiteral(name)])));
   }
 
   ast.Expression buildThrowFallThroughError() {
@@ skipping 905 matching lines @@
             scope.buildThis(),
             scope.buildName(node),
             scope.resolveInterfaceGet(element, auxiliary),
             scope.resolveInterfaceSet(element, auxiliary));
 
       case ElementKind.FUNCTION:
         FunctionElement function = element;
         if (isTopLevelFunction(function)) {
           return scope.staticAccess(node.name, function);
         }
-        if (function == function.library.loadLibraryFunction) {
-          return scope.unsupportedFeature('Deferred loading');
-        }
         return new VariableAccessor(scope.getVariableReference(function));
 
       case ElementKind.LOCAL_VARIABLE:
       case ElementKind.PARAMETER:
         VariableElement variable = element;
         var type = identical(node.staticType, variable.type)
             ? null
             : scope.buildType(node.staticType);
         return new VariableAccessor(scope.getVariableReference(element), type);
 
@@ skipping 1024 matching lines @@
     ast.Constructor constructor = currentMember;
     constructor.function = scope.buildFunctionNode(node.parameters, node.body,
         inferredReturnType: const ast.VoidType())..parent = constructor;
     handleNativeBody(node.body);
     if (node.body is EmptyFunctionBody && !constructor.isExternal) {
       var function = constructor.function;
       function.body = new ast.EmptyStatement()..parent = function;
     }
     for (var parameter in node.parameters.parameterElements) {
       if (parameter is FieldFormalParameterElement) {
-        ast.Initializer initializer;
-        if (parameter.field == null) {
-          initializer = new ast.LocalInitializer(
-              new ast.VariableDeclaration.forValue(scope
-                  .buildThrowCompileTimeErrorFromCode(
-                      CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTENT_FIELD,
-                      [parameter.name])));
-        } else {
-          initializer = new ast.FieldInitializer(
-              scope.getMemberReference(parameter.field),
-              new ast.VariableGet(scope.getVariableReference(parameter)));
-        }
+        var initializer = new ast.FieldInitializer(
+            scope.getMemberReference(parameter.field),
+            new ast.VariableGet(scope.getVariableReference(parameter)));
         constructor.initializers.add(initializer..parent = constructor);
       }
     }
     bool hasExplicitConstructorCall = false;
     for (var initializer in node.initializers) {
       var node = scope.buildInitializer(initializer);
       constructor.initializers.add(node..parent = constructor);
       if (node is ast.SuperInitializer || node is ast.RedirectingInitializer) {
         hasExplicitConstructorCall = true;
       }
@@ skipping 212 matching lines @@
     if (list[i - 1].compareTo(item) == 0) {
       ++deleted;
     } else if (deleted > 0) {
       list[i - deleted] = item;
     }
   }
   if (deleted > 0) {
     list.length -= deleted;
   }
 }