Split HForeign into HForeignCode and abstract base class.

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.
 
 part of ssa;
 
 class SsaFunctionCompiler implements FunctionCompiler {
   SsaCodeGeneratorTask generator;
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
@@ skipping 219 matching lines @@
   void redirectElement(Local from, CapturedVariable to) {
     assert(redirectionMapping[from] == null);
     redirectionMapping[from] = to;
     assert(isStoredInClosureField(from) || isBoxed(from));
   }
 
   HInstruction createBox() {
     // TODO(floitsch): Clean up this hack. Should we create a box-object by
     // just creating an empty object literal?
     JavaScriptBackend backend = builder.backend;
-    HInstruction box = new HForeign(js.js.parseForeignJS('{}'),
-                                    backend.nonNullType,
-                                    <HInstruction>[]);
+    HInstruction box = new HForeignCode(js.js.parseForeignJS('{}'),
+                                        backend.nonNullType,
+                                        <HInstruction>[]);
     builder.add(box);
     return box;
   }
 
   /**
    * If the scope (function or loop) [node] has captured variables then this
    * method creates a box and sets up the redirections.
    */
   void enterScope(ast.Node node, Element element) {
     // See if any variable in the top-scope of the function is captured. If yes
@@ skipping 1223 matching lines @@
 
   /**
    * Returns whether this builder is building code for [element].
    */
   bool isBuildingFor(Element element) {
     return work.element == element;
   }
 
   /// A stack of [DartType]s the have been seen during inlining of factory
   /// constructors.  These types are preserved in [HInvokeStatic]s and
-  /// [HForeignNews] inside the inline code and registered during code
+  /// [HForeignNew]s inside the inline code and registered during code
   /// generation for these nodes.
   // TODO(karlklose): consider removing this and keeping the (substituted)
   // types of the type variables in an environment (like the [LocalsHandler]).
   final List<DartType> currentInlinedInstantiations = <DartType>[];
 
   final List<AstInliningState> inliningStack = <AstInliningState>[];
 
   Local returnLocal;
   DartType returnType;
 
@@ skipping 1869 matching lines @@
       localsHandler.updateLocal(local, checkedOrTrusted);
     }
   }
 
   HInstruction invokeInterceptor(HInstruction receiver) {
     HInterceptor interceptor = new HInterceptor(receiver, backend.nonNullType);
     add(interceptor);
     return interceptor;
   }
 
-  HForeign createForeign(js.Template code,
-                         TypeMask type,
-                         List<HInstruction> inputs) {
-    return new HForeign(code, type, inputs);
+  HForeignCode createForeign(js.Template code,
+                             TypeMask type,
+                             List<HInstruction> inputs) {
+    return new HForeignCode(code, type, inputs);
   }
 
   HLiteralList buildLiteralList(List<HInstruction> inputs) {
     return new HLiteralList(inputs, backend.extendableArrayType);
   }
 
   // TODO(karlklose): change construction of the representations to be GVN'able
   // (dartbug.com/7182).
   HInstruction buildTypeArgumentRepresentations(DartType type) {
     // Compute the representation of the type arguments, including access
@@ skipping 240 matching lines @@
     native.NativeBehavior nativeBehavior =
         compiler.enqueuer.resolution.nativeEnqueuer.getNativeBehaviorOf(node);
 
     List<HInstruction> inputs = <HInstruction>[];
     addGenericSendArgumentsToList(link.tail.tail, inputs);
 
     TypeMask ssaType =
         TypeMaskFactory.fromNativeBehavior(nativeBehavior, compiler);
 
     if (nativeBehavior.codeTemplate.isExpression) {
-      push(new HForeign(nativeBehavior.codeTemplate, ssaType, inputs,
-                        effects: nativeBehavior.sideEffects,
-                        nativeBehavior: nativeBehavior));
+      push(new HForeignCode(nativeBehavior.codeTemplate, ssaType, inputs,
+                            effects: nativeBehavior.sideEffects,
+                            nativeBehavior: nativeBehavior));
     } else {
-      push(new HForeign(nativeBehavior.codeTemplate, ssaType, inputs,
-                        isStatement: true,
-                        effects: nativeBehavior.sideEffects,
-                        nativeBehavior: nativeBehavior,
-                        canThrow: true));
+      push(new HForeignCode(nativeBehavior.codeTemplate, ssaType, inputs,
+                            isStatement: true,
+                            effects: nativeBehavior.sideEffects,
+                            nativeBehavior: nativeBehavior,
+                            canThrow: true));
     }
   }
 
   void handleJsStringConcat(ast.Send node) {
     List<HInstruction> inputs = <HInstruction>[];
     addGenericSendArgumentsToList(node.arguments, inputs);
     if (inputs.length != 2) {
       compiler.internalError(node.argumentsNode, 'Two arguments expected.');
     }
     push(new HStringConcat(inputs[0], inputs[1], node, backend.stringType));
   }
 
   void handleForeignJsCurrentIsolateContext(ast.Send node) {
     if (!node.arguments.isEmpty) {
       compiler.internalError(node,
           'Too many arguments to JS_CURRENT_ISOLATE_CONTEXT.');
     }
 
     if (!compiler.hasIsolateSupport) {
       // If the isolate library is not used, we just generate code
       // to fetch the current isolate.
       String name = backend.namer.currentIsolate;
-      push(new HForeign(js.js.parseForeignJS(name),
-                        backend.dynamicType,
-                        <HInstruction>[]));
+      push(new HForeignCode(js.js.parseForeignJS(name),
+                            backend.dynamicType,
+                            <HInstruction>[]));
     } else {
       // Call a helper method from the isolate library. The isolate
       // library uses its own isolate structure, that encapsulates
       // Leg's isolate.
       Element element = backend.isolateHelperLibrary.find('_currentIsolate');
       if (element == null) {
         compiler.internalError(node,
             'Isolate library and compiler mismatch.');
       }
       pushInvokeStatic(null, element, [], backend.dynamicType);
@@ skipping 113 matching lines @@
     }
     HConstant hConstant = globalNameHNode;
     StringConstantValue constant = hConstant.constant;
     String globalName = constant.primitiveValue.slowToString();
     js.Template expr = js.js.expressionTemplateYielding(
         backend.emitter.generateEmbeddedGlobalAccess(globalName));
     native.NativeBehavior nativeBehavior =
         compiler.enqueuer.resolution.nativeEnqueuer.getNativeBehaviorOf(node);
     TypeMask ssaType =
         TypeMaskFactory.fromNativeBehavior(nativeBehavior, compiler);
-    push(new HForeign(expr, ssaType, const []));
+    push(new HForeignCode(expr, ssaType, const []));
   }
 
   void handleJsInterceptorConstant(ast.Send node) {
     // Single argument must be a TypeConstant which is converted into a
     // InterceptorConstant.
     if (!node.arguments.isEmpty && node.arguments.tail.isEmpty) {
       ast.Node argument = node.arguments.head;
       visit(argument);
       HInstruction argumentInstruction = pop();
       if (argumentInstruction is HConstant) {
@@ skipping 51 matching lines @@
     // and implementation signatures. Currently it is need because the
     // signatures have different elements for parameters.
     FunctionElement implementation = function.implementation;
     FunctionSignature params = implementation.functionSignature;
     if (params.optionalParameterCount != 0) {
       compiler.internalError(closure,
           '"$name" does not handle closure with optional parameters.');
     }
 
     registry.registerStaticUse(element);
-    push(new HForeign(js.js.expressionTemplateYielding(
+    push(new HForeignCode(js.js.expressionTemplateYielding(
                           backend.emitter.staticFunctionAccess(element)),
-                      backend.dynamicType,
-                      <HInstruction>[]));
+                          backend.dynamicType,
+                          <HInstruction>[]));
     return params;
   }
 
   void handleForeignDartClosureToJs(ast.Send node, String name) {
     // TODO(ahe): This implements DART_CLOSURE_TO_JS and should probably take
     // care to wrap the closure in another closure that saves the current
     // isolate.
     handleForeignRawFunctionRef(node, name);
   }
 
   void handleForeignSetCurrentIsolate(ast.Send node) {
     if (node.arguments.isEmpty || !node.arguments.tail.isEmpty) {
       compiler.internalError(node.argumentsNode,
           'Exactly one argument required.');
     }
     visit(node.arguments.head);
     String isolateName = backend.namer.currentIsolate;
     SideEffects sideEffects = new SideEffects.empty();
     sideEffects.setAllSideEffects();
-    push(new HForeign(js.js.parseForeignJS("$isolateName = #"),
-                      backend.dynamicType,
-                      <HInstruction>[pop()],
-                      effects: sideEffects));
+    push(new HForeignCode(js.js.parseForeignJS("$isolateName = #"),
+                          backend.dynamicType,
+                          <HInstruction>[pop()],
+                          effects: sideEffects));
   }
 
   void handleForeignDartObjectJsConstructorFunction(ast.Send node) {
     if (!node.arguments.isEmpty) {
       compiler.internalError(node.argumentsNode, 'Too many arguments.');
     }
-    push(new HForeign(js.js.expressionTemplateYielding(
+    push(new HForeignCode(js.js.expressionTemplateYielding(
                           backend.emitter.typeAccess(compiler.objectClass)),
-                      backend.dynamicType,
-                      <HInstruction>[]));
+                          backend.dynamicType,
+                          <HInstruction>[]));
   }
 
   void handleForeignJsCurrentIsolate(ast.Send node) {
     if (!node.arguments.isEmpty) {
       compiler.internalError(node.argumentsNode, 'Too many arguments.');
     }
-    push(new HForeign(js.js.parseForeignJS(backend.namer.currentIsolate),
-                      backend.dynamicType,
-                      <HInstruction>[]));
+    push(new HForeignCode(js.js.parseForeignJS(backend.namer.currentIsolate),
+                          backend.dynamicType,
+                          <HInstruction>[]));
   }
 
   visitForeignSend(ast.Send node) {
     Selector selector = elements.getSelector(node);
     String name = selector.name;
     if (name == 'JS') {
       handleForeignJs(node);
     } else if (name == 'JS_CURRENT_ISOLATE_CONTEXT') {
       handleForeignJsCurrentIsolateContext(node);
     } else if (name == 'JS_CALL_IN_ISOLATE') {
@@ skipping 469 matching lines @@
       js.Template code = js.js.parseForeignJS('Array(#)');
       var behavior = new native.NativeBehavior();
       behavior.typesReturned.add(expectedType);
       // The allocation can throw only if the given length is a double
       // or negative.
       bool canThrow = true;
       if (inputs[0].isInteger(compiler) && inputs[0] is HConstant) {
         var constant = inputs[0];
         if (constant.constant.primitiveValue >= 0) canThrow = false;
       }
-      HForeign foreign = new HForeign(
+      HForeignCode foreign = new HForeignCode(
           code, elementType, inputs, nativeBehavior: behavior,
           canThrow: canThrow);
       push(foreign);
       TypesInferrer inferrer = compiler.typesTask.typesInferrer;
       if (inferrer.isFixedArrayCheckedForGrowable(send)) {
         js.Template code = js.js.parseForeignJS(r'#.fixed$length = Array');
         // We set the instruction as [canThrow] to avoid it being dead code.
         // We need a finer grained side effect.
-        add(new HForeign(
+        add(new HForeignCode(
               code, backend.nullType, [stack.last], canThrow: true));
       }
     } else if (isGrowableListConstructorCall) {
       push(buildLiteralList(<HInstruction>[]));
       stack.last.instructionType = elementType;
     } else {
       ClassElement cls = constructor.enclosingClass;
       if (cls.isAbstract && constructor.isGenerativeConstructor) {
         generateAbstractClassInstantiationError(send, cls.name);
         return;
@@ skipping 2510 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }