Revert "Towards compiling Hello World!" and "Compile and run Hello World!"

pkg/compiler/lib/src/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 import 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 37 matching lines @@
 import 'locals_handler.dart';
 import 'loop_handler.dart';
 import 'nodes.dart';
 import 'optimize.dart';
 import 'ssa.dart';
 import 'ssa_branch_builder.dart';
 import 'type_builder.dart';
 import 'types.dart';
 
 abstract class SsaAstBuilderBase extends CompilerTask
-    with SsaBuilderFieldMixin
     implements SsaBuilderTask {
   final JavaScriptBackend backend;
 
   SsaAstBuilderBase(this.backend) : super(backend.compiler.measurer);
 
-  ConstantValue getFieldInitialConstantValue(FieldElement field) {
-    ConstantExpression constant = field.constant;
-    if (constant != null) {
-      ConstantValue initialValue = backend.constants.getConstantValue(constant);
-      if (initialValue == null) {
-        assert(
-            field.isInstanceMember ||
-                constant.isImplicit ||
-                constant.isPotential,
-            failedAt(
-                field,
-                "Constant expression without value: "
-                "${constant.toStructuredText()}."));
+  /// Handle field initializer of `work.element`. Returns `true` if no code
+  /// is needed for the field.
+  ///
+  /// If `work.element` is a field with a constant initializer, the value is
+  /// registered with the world impact. Otherwise the cyclic-throw helper is
+  /// registered for the lazy value computation.
+  ///
+  /// If the field is constant, no code is needed for the field and the method
+  /// return `true`.
+  bool handleConstantField(
+      ElementCodegenWorkItem work, ClosedWorld closedWorld) {
+    MemberElement element = work.element;
+    if (element.isField) {
+      FieldElement field = element;
+      ConstantExpression constant = field.constant;
+      if (constant != null) {
+        ConstantValue initialValue =
+            backend.constants.getConstantValue(constant);
+        if (initialValue != null) {
+          work.registry.worldImpact
+              .registerConstantUse(new ConstantUse.init(initialValue));
+          // We don't need to generate code for static or top-level
+          // variables. For instance variables, we may need to generate
+          // the checked setter.
+          if (field.isStatic || field.isTopLevel) {
+            /// No code is created for this field.
+            return true;
+          }
+        } else {
+          assert(
+              field.isInstanceMember ||
+                  constant.isImplicit ||
+                  constant.isPotential,
+              failedAt(
+                  field,
+                  "Constant expression without value: "
+                  "${constant.toStructuredText()}."));
+        }
+      } else {
+        // If the constant-handler was not able to produce a result we have to
+        // go through the builder (below) to generate the lazy initializer for
+        // the static variable.
+        // We also need to register the use of the cyclic-error helper.
+        work.registry.worldImpact.registerStaticUse(new StaticUse.staticInvoke(
+            closedWorld.commonElements.cyclicThrowHelper,
+            CallStructure.ONE_ARG));
       }
-      return initialValue;
     }
-    return null;
+    return false;
   }
 }
 
 class SsaAstBuilderTask extends SsaAstBuilderBase {
   final CodeEmitterTask emitter;
   final SourceInformationStrategy sourceInformationFactory;
 
   String get name => 'SSA builder';
 
   SsaAstBuilderTask(JavaScriptBackend backend, this.sourceInformationFactory)
       : emitter = backend.emitter,
         super(backend);
 
   DiagnosticReporter get reporter => backend.reporter;
 
   HGraph build(ElementCodegenWorkItem work, ClosedWorld closedWorld) {
     return measure(() {
-      if (handleConstantField(work.element, work.registry, closedWorld)) {
+      if (handleConstantField(work, closedWorld)) {
         // No code is generated for `work.element`.
         return null;
       }
       MemberElement element = work.element.implementation;
       return reporter.withCurrentElement(element, () {
         SsaBuilder builder = new SsaBuilder(
             work.element.implementation,
             work.resolvedAst,
             work.registry,
             backend,
@@ skipping 6735 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }