Further reduce use of Element in codegen.

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 CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart' show Selectors;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
@@ skipping 730 matching lines @@
     }
 
     if (type.isObject || type.treatAsDynamic) {
       return graph.addConstantBool(true, closedWorld);
     }
 
     HInstruction expression = node.expression;
     if (expression.isInteger(closedWorld)) {
       if (element == commonElements.intClass ||
           element == commonElements.numClass ||
-          Elements.isNumberOrStringSupertype(element, commonElements)) {
+          commonElements.isNumberOrStringSupertype(element)) {
         return graph.addConstantBool(true, closedWorld);
       } else if (element == commonElements.doubleClass) {
         // We let the JS semantics decide for that check. Currently
         // the code we emit will always return true.
         return node;
       } else {
         return graph.addConstantBool(false, closedWorld);
       }
     } else if (expression.isDouble(closedWorld)) {
       if (element == commonElements.doubleClass ||
           element == commonElements.numClass ||
-          Elements.isNumberOrStringSupertype(element, commonElements)) {
+          commonElements.isNumberOrStringSupertype(element)) {
         return graph.addConstantBool(true, closedWorld);
       } else if (element == commonElements.intClass) {
         // We let the JS semantics decide for that check. Currently
         // the code we emit will return true for a double that can be
         // represented as a 31-bit integer and for -0.0.
         return node;
       } else {
         return graph.addConstantBool(false, closedWorld);
       }
     } else if (expression.isNumber(closedWorld)) {
@@ skipping 1525 matching lines @@
   void visitFieldSet(HFieldSet instruction) {
     HInstruction receiver = instruction.getDartReceiver(closedWorld).nonCheck();
     memorySet.registerFieldValueUpdate(
         instruction.element, receiver, instruction.inputs.last);
   }
 
   void visitCreate(HCreate instruction) {
     memorySet.registerAllocation(instruction);
     if (shouldTrackInitialValues(instruction)) {
       int argumentIndex = 0;
-      instruction.element.forEachInstanceField((_, FieldElement member) {
+      compiler.codegenWorld.forEachInstanceField(instruction.element,
+          (_, FieldElement 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(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.
@@ skipping 418 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }