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 36 matching lines @@
 import 'jump_handler.dart';
 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 implements SsaBuilder {
+abstract class SsaAstBuilderBase extends SsaBuilderFieldMixin
+    implements SsaBuilder {
   final CompilerTask task;
   final JavaScriptBackend backend;
 
   SsaAstBuilderBase(this.task, this.backend);
 
-  /// 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));
+  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()}."));
       }
+      return initialValue;
     }
-    return false;
+    return null;
   }
 }
 
 class SsaAstBuilder extends SsaAstBuilderBase {
   final CodeEmitterTask emitter;
   final SourceInformationStrategy sourceInformationFactory;
 
   SsaAstBuilder(CompilerTask task, JavaScriptBackend backend,
       this.sourceInformationFactory)
       : emitter = backend.emitter,
         super(task, backend);
 
   DiagnosticReporter get reporter => backend.reporter;
 
   HGraph build(ElementCodegenWorkItem work, ClosedWorld closedWorld) {
     return task.measure(() {
-      if (handleConstantField(work, closedWorld)) {
+      if (handleConstantField(work.element, work.registry, closedWorld)) {
         // No code is generated for `work.element`.
         return null;
       }
       MemberElement element = work.element.implementation;
       return reporter.withCurrentElement(element, () {
         SsaAstGraphBuilder builder = new SsaAstGraphBuilder(
             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);
 }