Split HForeign into HForeignCode and abstract base class.

pkg/compiler/lib/src/ssa/nodes.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;
 
 abstract class HVisitor<R> {
   R visitAdd(HAdd node);
   R visitAwait(HAwait node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
   R visitBitXor(HBitXor node);
   R visitBoolify(HBoolify node);
   R visitBoundsCheck(HBoundsCheck node);
   R visitBreak(HBreak node);
   R visitConstant(HConstant node);
   R visitContinue(HContinue node);
   R visitDivide(HDivide node);
   R visitExit(HExit node);
   R visitExitTry(HExitTry node);
   R visitFieldGet(HFieldGet node);
   R visitFieldSet(HFieldSet node);
-  R visitForeign(HForeign node);
+  R visitForeignCode(HForeignCode node);
   R visitForeignNew(HForeignNew node);
   R visitGoto(HGoto node);
   R visitGreater(HGreater node);
   R visitGreaterEqual(HGreaterEqual node);
   R visitIdentity(HIdentity node);
   R visitIf(HIf node);
   R visitIndex(HIndex node);
   R visitIndexAssign(HIndexAssign node);
   R visitInterceptor(HInterceptor node);
   R visitInvokeClosure(HInvokeClosure node);
@@ skipping 250 matching lines @@
   visitBoundsCheck(HBoundsCheck node) => visitCheck(node);
   visitBreak(HBreak node) => visitJump(node);
   visitContinue(HContinue node) => visitJump(node);
   visitCheck(HCheck node) => visitInstruction(node);
   visitConstant(HConstant node) => visitInstruction(node);
   visitDivide(HDivide node) => visitBinaryArithmetic(node);
   visitExit(HExit node) => visitControlFlow(node);
   visitExitTry(HExitTry node) => visitControlFlow(node);
   visitFieldGet(HFieldGet node) => visitFieldAccess(node);
   visitFieldSet(HFieldSet node) => visitFieldAccess(node);
-  visitForeign(HForeign node) => visitInstruction(node);
-  visitForeignNew(HForeignNew node) => visitForeign(node);
+  visitForeignCode(HForeignCode node) => visitInstruction(node);
+  visitForeignNew(HForeignNew node) => visitInstruction(node);
   visitGoto(HGoto node) => visitControlFlow(node);
   visitGreater(HGreater node) => visitRelational(node);
   visitGreaterEqual(HGreaterEqual node) => visitRelational(node);
   visitIdentity(HIdentity node) => visitRelational(node);
   visitIf(HIf node) => visitConditionalBranch(node);
   visitIndex(HIndex node) => visitInstruction(node);
   visitIndexAssign(HIndexAssign node) => visitInstruction(node);
   visitInterceptor(HInterceptor node) => visitInstruction(node);
   visitInvokeClosure(HInvokeClosure node)
       => visitInvokeDynamic(node);
@@ skipping 1384 matching lines @@
       : super(variable, <HInstruction>[local, value],
               const TypeMask.nonNullEmpty());
 
   accept(HVisitor visitor) => visitor.visitLocalSet(this);
 
   HLocalValue get local => inputs[0];
   HInstruction get value => inputs[1];
   bool isJsStatement() => true;
 }
 
-class HForeign extends HInstruction {
+abstract class HForeign extends HInstruction {
+  HForeign(TypeMask type, List<HInstruction> inputs) : super(inputs, type);
+
+  bool get isStatement => false;
+  native.NativeBehavior get nativeBehavior => null;
+
+  bool canThrow() {
+    return sideEffects.hasSideEffects()
+        || sideEffects.dependsOnSomething();
+  }
+}
+
+class HForeignCode extends HForeign {
   final js.Template codeTemplate;
   final bool isStatement;
   final bool _canThrow;
   final native.NativeBehavior nativeBehavior;
 
-  HForeign(this.codeTemplate,
+  HForeignCode(this.codeTemplate,
            TypeMask type,
            List<HInstruction> inputs,
            {this.isStatement: false,
             SideEffects effects,
             native.NativeBehavior nativeBehavior,
             canThrow: false})
       : this.nativeBehavior = nativeBehavior,
         this._canThrow = canThrow,
-        super(inputs, type) {
+        super(type, inputs) {
+    if(codeTemplate == null) throw this;

[sra1, 2015/03/24 03:00:47]

space after 'if'

[herhut, 2015/05/26 14:32:18]

This has been fixed in the meanwhile.

     if (effects == null && nativeBehavior != null) {
       effects = nativeBehavior.sideEffects;
     }
     if (effects != null) sideEffects.add(effects);
   }
 
-  HForeign.statement(codeTemplate, List<HInstruction> inputs,
+  HForeignCode.statement(codeTemplate, List<HInstruction> inputs,
                      SideEffects effects,
                      native.NativeBehavior nativeBehavior,
                      TypeMask type)
       : this(codeTemplate, type, inputs, isStatement: true,
              effects: effects, nativeBehavior: nativeBehavior);
 
-  accept(HVisitor visitor) => visitor.visitForeign(this);
+  accept(HVisitor visitor) => visitor.visitForeignCode(this);
 
   bool isJsStatement() => isStatement;
-  bool canThrow() {
-    return _canThrow
-        || sideEffects.hasSideEffects()
-        || sideEffects.dependsOnSomething();
-  }
+  bool canThrow() => _canThrow || super.canThrow();
 }
 
 class HForeignNew extends HForeign {
   ClassElement element;
 
   /// If this field is not `null`, this call is from an inlined constructor and
   /// we have to register the instantiated type in the code generator. The
   /// [instructionType] of this node is not enough, because we also need the
   /// type arguments. See also [SsaFromAstMixin.currentInlinedInstantiations].
   List<DartType> instantiatedTypes;
 
   HForeignNew(this.element, TypeMask type, List<HInstruction> inputs,
               [this.instantiatedTypes])
-      : super(null, type, inputs);
+      : super(type, inputs);
 
   accept(HVisitor visitor) => visitor.visitForeignNew(this);
 }
 
 abstract class HInvokeBinary extends HInstruction {
   final Selector selector;
   HInvokeBinary(HInstruction left, HInstruction right, this.selector, type)
       : super(<HInstruction>[left, right], type) {
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
@@ skipping 1360 matching lines @@
 class HDynamicType extends HRuntimeType {
   HDynamicType(DynamicType dartType, TypeMask instructionType)
       : super(const <HInstruction>[], dartType, instructionType);
 
   accept(HVisitor visitor) => visitor.visitDynamicType(this);
 
   int typeCode() => HInstruction.DYNAMIC_TYPE_TYPECODE;
 
   bool typeEquals(HInstruction other) => other is HDynamicType;
 }