Rename HForeignNew -> HCreate

pkg/compiler/lib/src/ssa/optimize.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 '../common/codegen.dart' show CodegenWorkItem;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../core_types.dart' show CoreClasses;
@@ skipping 1147 matching lines @@
       return node;
     }
 
     // Look for an allocation with type information and re-write type variable
     // as a function of the type parameters of the allocation.  This effectively
     // store-forwards a type variable read through an allocation.
 
     // Match:
     //
     //     setRuntimeTypeInfo(
-    //         HForeignNew(ClassElement),
+    //         HCreate(ClassElement),
     //         HTypeInfoExpression(t_0, t_1, t_2, ...));
     //
     // The `t_i` are the values of the type parameters of ClassElement.
     if (object is HInvokeStatic) {
       if (object.element == helpers.setRuntimeTypeInfo) {
         HInstruction allocation = object.inputs[0];
-        if (allocation is HForeignNew) {
+        if (allocation is HCreate) {
           HInstruction typeInfo = object.inputs[1];
           if (typeInfo is HTypeInfoExpression) {
             return finishSubstituted(
                 allocation.element, (int index) => typeInfo.inputs[index]);
           }
         }
         return node;
       }
       // TODO(sra): Factory constructors pass type arguments after the value
       // arguments. The [select] argument indexes into these type arguments.
     }
 
     // Non-generic type (which extends or mixes in a generic type, for example
     // CodeUnits extends UnmodifiableListBase<int>).
     // Also used for raw-type when the type parameters are elided.
-    if (object is HForeignNew) {
+    if (object is HCreate) {
       return finishSubstituted(
           object.element,
           // If there are type arguments, all type arguments are 'dynamic'.
           (int i) => graph.addConstantNull(compiler));
     }
 
     return node;
   }
 }
 
@@ skipping 989 matching lines @@
       memorySet.registerFieldValue(element, receiver, instruction);
     }
   }
 
   void visitFieldSet(HFieldSet instruction) {
     HInstruction receiver = instruction.getDartReceiver(compiler).nonCheck();
     memorySet.registerFieldValueUpdate(
         instruction.element, receiver, instruction.inputs.last);
   }
 
-  void visitForeignNew(HForeignNew instruction) {
+  void visitCreate(HCreate instruction) {
     memorySet.registerAllocation(instruction);
     if (shouldTrackInitialValues(instruction)) {
       int argumentIndex = 0;
       instruction.element.forEachInstanceField((_, Element member) {
         if (compiler.elementHasCompileTimeError(member)) return;
         memorySet.registerFieldValue(
             member, instruction, instruction.inputs[argumentIndex++]);
       }, includeSuperAndInjectedMembers: true);
     }
     // In case this instruction has as input non-escaping objects, we
     // need to mark these objects as escaping.
     memorySet.killAffectedBy(instruction);
   }
 
-  bool shouldTrackInitialValues(HForeignNew instruction) {
+  bool shouldTrackInitialValues(HCreate instruction) {
     // Don't track initial field values of an allocation that are
     // unprofitable. We search the chain of single uses in allocations for a
     // limited depth.
 
     const MAX_HEAP_DEPTH = 5;
 
     bool interestingUse(HInstruction instruction, int heapDepth) {
       // Heuristic: if the allocation is too deep in heap it is unlikely we will
       // recover a field by load-elimination.
       // TODO(sra): We can measure this depth by looking at load chains.
       if (heapDepth == MAX_HEAP_DEPTH) return false;
       // There are multiple uses so do the full store analysis.
       if (instruction.usedBy.length != 1) return true;
       HInstruction use = instruction.usedBy.single;
       // When the only use is an allocation, the allocation becomes the only
       // heap alias for the current instruction.
-      if (use is HForeignNew) return interestingUse(use, heapDepth + 1);
+      if (use is HCreate) return interestingUse(use, heapDepth + 1);
       if (use is HLiteralList) return interestingUse(use, heapDepth + 1);
       if (use is HInvokeStatic) {
         // Assume the argument escapes. All we do with our initial allocation is
         // have it escape or store it into an object that escapes.
         return false;
         // TODO(sra): Handle more functions. `setRuntimeTypeInfo` does not
         // actually kill it's input, but we don't make use of that elsewhere so
         // there is not point in checking here.
       }
       if (use is HPhi) {
@@ skipping 107 matching lines @@
     if (couldBeTypedArray(first) && couldBeTypedArray(second)) return true;
     return !first.instructionType
         .isDisjoint(second.instructionType, compiler.world);
   }
 
   bool isFinal(Element element) {
     return compiler.world.fieldNeverChanges(element);
   }
 
   bool isConcrete(HInstruction instruction) {
-    return instruction is HForeignNew ||
+    return instruction is HCreate ||
         instruction is HConstant ||
         instruction is HLiteralList;
   }
 
   bool couldBeTypedArray(HInstruction receiver) {
     JavaScriptBackend backend = compiler.backend;
     return backend.couldBeTypedArray(receiver.instructionType);
   }
 
   /**
@@ skipping 216 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }