Add J-elements

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 extends CompilerTask
-    implements SsaBuilderTask {
+abstract class SsaAstBuilderBase implements SsaBuilder {
+  final CompilerTask task;
   final JavaScriptBackend backend;
 
-  SsaAstBuilderBase(this.backend) : super(backend.compiler.measurer);
+  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`.
@@ skipping 33 matching lines @@
         // 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 false;
   }
 }
 
-class SsaAstBuilderTask extends SsaAstBuilderBase {
+class SsaAstBuilder extends SsaAstBuilderBase {
   final CodeEmitterTask emitter;
   final SourceInformationStrategy sourceInformationFactory;
 
   String get name => 'SSA builder';

[Siggi Cherem (dart-lang), 2017/06/15 23:10:49]

delete?

[Johnni Winther, 2017/06/16 11:06:44]

Done.

 
-  SsaAstBuilderTask(JavaScriptBackend backend, this.sourceInformationFactory)
+  SsaAstBuilder(CompilerTask task, JavaScriptBackend backend,
+      this.sourceInformationFactory)
       : emitter = backend.emitter,
-        super(backend);
+        super(task, backend);
 
   DiagnosticReporter get reporter => backend.reporter;
 
   HGraph build(ElementCodegenWorkItem work, ClosedWorld closedWorld) {
-    return measure(() {
+    return task.measure(() {
       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(
+        SsaAstGraphBuilder builder = new SsaAstGraphBuilder(
             work.element.implementation,
             work.resolvedAst,
             work.registry,
             backend,
             closedWorld,
             emitter.nativeEmitter,
             sourceInformationFactory);
         HGraph graph = builder.build();
 
         // Default arguments are handled elsewhere, but we must ensure
@@ skipping 26 matching lines @@
         }
         return graph;
       });
     });
   }
 }
 
 /**
  * This class builds SSA nodes for functions represented in AST.
  */
-class SsaBuilder extends ast.Visitor
+class SsaAstGraphBuilder extends ast.Visitor
     with
         BaseImplementationOfCompoundsMixin,
         BaseImplementationOfSetIfNullsMixin,
         BaseImplementationOfSuperIndexSetIfNullMixin,
         SemanticSendResolvedMixin,
         NewBulkMixin,
         ErrorBulkMixin,
         GraphBuilder
     implements SemanticSendVisitor {
   /// The element for which this SSA builder is being used.
@@ skipping 58 matching lines @@
         element.asyncMarker == AsyncMarker.ASYNC);
   }
 
   /// Handles the building of loops.
   LoopHandler<ast.Node> loopHandler;
 
   /// Handles type check building.
   TypeBuilder typeBuilder;
 
   // TODO(sigmund): make most args optional
-  SsaBuilder(
+  SsaAstGraphBuilder(
       this.target,
       this.resolvedAst,
       this.registry,
       JavaScriptBackend backend,
       this.closedWorld,
       this.nativeEmitter,
       SourceInformationStrategy sourceInformationFactory)
       : this.infoReporter = backend.compiler.dumpInfoTask,
         this.backend = backend,
         this.constantSystem = backend.constantSystem,
@@ skipping 6318 matching lines @@
     generateRuntimeError(node, error.message);
   }
 }
 
 /**
  * Visitor that handles generation of string literals (LiteralString,
  * StringInterpolation), and otherwise delegates to the given visitor for
  * non-literal subexpressions.
  */
 class StringBuilderVisitor extends ast.Visitor {
-  final SsaBuilder builder;
+  final SsaAstGraphBuilder builder;
   final ast.Node diagnosticNode;
 
   /**
    * The string value generated so far.
    */
   HInstruction result = null;
 
   StringBuilderVisitor(this.builder, this.diagnosticNode);
 
   void visit(ast.Node node) {
@@ skipping 264 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }