Share more logic between the Ssa(Ast)Builder and SsaKernelBuilder

pkg/compiler/lib/src/js_backend/backend.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.
 
 library js_backend.backend;
 
 import '../common.dart';
 import '../common/backend_api.dart'
     show ForeignResolver, NativeRegistry, ImpactTransformer;
-import '../common/codegen.dart' show CodegenImpact, CodegenWorkItem;
+import '../common/codegen.dart' show CodegenWorkItem;
 import '../common/names.dart' show Uris;
 import '../common/resolution.dart' show Resolution, Target;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../common_elements.dart' show CommonElements;
 import '../deferred_load.dart' show DeferredLoadTask;
 import '../dump_info.dart' show DumpInfoTask;
@@ skipping 23 matching lines @@
 import '../library_loader.dart' show LoadedLibraries;
 import '../native/native.dart' as native;
 import '../native/resolver.dart';
 import '../ssa/ssa.dart' show SsaFunctionCompiler;
 import '../tracer.dart';
 import '../tree/tree.dart';
 import '../types/types.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector;
 import '../universe/world_builder.dart';
-import '../universe/use.dart' show ConstantUse, StaticUse;
 import '../universe/world_impact.dart'
     show ImpactStrategy, ImpactUseCase, WorldImpact, WorldImpactVisitor;
 import '../util/util.dart';
 import '../world.dart' show ClosedWorld, ClosedWorldRefiner;
 import 'annotations.dart';
 import 'backend_impact.dart';
 import 'backend_serialization.dart' show JavaScriptBackendSerialization;
 import 'backend_usage.dart';
 import 'checked_mode_helpers.dart';
 import 'codegen_listener.dart';
@@ skipping 266 matching lines @@
     return [commonElements.closureClass, commonElements.jsIndexableClass];
   }
 
   FunctionCompiler functionCompiler;
 
   CodeEmitterTask emitter;
 
   /**
    * The generated code as a js AST for compiled methods.
    */
-  final Map<MemberElement, jsAst.Expression> generatedCode =
-      <MemberElement, jsAst.Expression>{};
+  final Map<MemberEntity, jsAst.Expression> generatedCode =
+      <MemberEntity, jsAst.Expression>{};
 
   FunctionInlineCache inlineCache = new FunctionInlineCache();
 
   /// If [true], the compiler will emit code that logs whenever a method is
   /// called. When TRACE_METHOD is 'console' this will be logged
   /// directly in the JavaScript console. When TRACE_METHOD is 'post' the
   /// information will be sent to a server via a POST request.
   static const String TRACE_METHOD = const String.fromEnvironment('traceCalls');
   static const bool TRACE_CALLS =
       TRACE_METHOD == 'post' || TRACE_METHOD == 'console';
@@ skipping 550 matching lines @@
             closedWorld.backendUsage,
             rtiNeed,
             customElementsCodegenAnalysis,
             typeVariableCodegenAnalysis,
             lookupMapAnalysis,
             mirrorsCodegenAnalysis,
             nativeCodegenEnqueuer));
   }
 
   WorldImpact codegen(CodegenWorkItem work, ClosedWorld closedWorld) {
-    MemberElement element = work.element;
+    MemberEntity element = work.element;
     if (compiler.elementHasCompileTimeError(element)) {
       DiagnosticMessage message =
           // If there's more than one error, the first is probably most
           // informative, as the following errors may be side-effects of the
           // first error.
           compiler.elementsWithCompileTimeErrors[element].first;
       String messageText = message.message.computeMessage();
       jsAst.LiteralString messageLiteral =
           js.escapedString("Compile time error in $element: $messageText");
       generatedCode[element] =
           js("function () { throw new Error(#); }", [messageLiteral]);
-      return const CodegenImpact();
-    }
-    var kind = element.kind;
-    if (kind == ElementKind.TYPEDEF) {
       return const WorldImpact();
     }
     if (element.isConstructor &&
         element.enclosingClass == commonElements.jsNullClass) {
       // Work around a problem compiling JSNull's constructor.
-      return const CodegenImpact();
-    }
-    if (kind.category == ElementCategory.VARIABLE) {
-      FieldElement variableElement = element;
-      ConstantExpression constant = variableElement.constant;
-      if (constant != null) {
-        ConstantValue initialValue = 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 (Elements.isStaticOrTopLevel(element)) {
-            return _codegenImpactTransformer
-                .transformCodegenImpact(work.registry.worldImpact);
-          }
-        } else {
-          assert(invariant(
-              variableElement,
-              variableElement.isInstanceMember ||
-                  constant.isImplicit ||
-                  constant.isPotential,
-              message: "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(
-            commonElements.cyclicThrowHelper, CallStructure.ONE_ARG));
-      }
+      return const WorldImpact();
     }
 
     jsAst.Fun function = functionCompiler.compile(work, closedWorld);
-    if (function.sourceInformation == null) {
-      function = function.withSourceInformation(
-          sourceInformationStrategy.buildSourceMappedMarker());
+    if (function != null) {
+      if (function.sourceInformation == null) {
+        function = function.withSourceInformation(
+            sourceInformationStrategy.buildSourceMappedMarker());
+      }
+      generatedCode[element] = function;
     }
-    generatedCode[element] = function;
     WorldImpact worldImpact = _codegenImpactTransformer
         .transformCodegenImpact(work.registry.worldImpact);
     compiler.dumpInfoTask.registerImpact(element, worldImpact);
     return worldImpact;
   }
 
   native.NativeResolutionEnqueuer get nativeResolutionEnqueuerForTesting =>
       _nativeResolutionEnqueuer;
 
   native.NativeEnqueuer get nativeCodegenEnqueuer => _nativeCodegenEnqueuer;
@@ skipping 446 matching lines @@
 
   bool canUseAliasedSuperMember(MemberEntity member, Selector selector) {
     return !selector.isGetter;
   }
 
   /// Returns `true` if [member] is called from a subclass via `super`.
   bool isAliasedSuperMember(MemberEntity member) {
     return _aliasedSuperMembers.contains(member);
   }
 }