Change the type inference for fields in dart2js

lib/compiler/implementation/ssa/codegen.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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
@@ skipping 1616 matching lines @@
     if (value.guaranteedType.union(HType.NUMBER) == HType.NUMBER) return true;
     if (value is HBinaryArithmetic) {
       return (isSimpleFieldNumberComputation(value.left, node) &&
               isSimpleFieldNumberComputation(value.right, node));
     }
     if (value is HFieldGet) return value.element == node.element;
     return false;
   }
 
   visitFieldSet(HFieldSet node) {
-    if (work.element.isGenerativeConstructorBody() &&
-        node.element.isMember() &&
-        node.value.hasGuaranteedType() &&
-        node.block.dominates(currentGraph.exit)) {
-      backend.updateFieldConstructorSetters(node.element,
-                                            node.value.guaranteedType);
-    }
     String name = backend.namer.getName(node.element);
     DartType type = types[node.receiver].computeType(compiler);
     if (type != null) {
       if (!work.element.isGenerativeConstructorBody()) {
         world.registerFieldSetter(
             node.element.name, node.element.getLibrary(), type);
-      }
-      // Determine the types seen so far for the field. If only number
-      // types have been seen and the value of the field set is a
-      // simple number computation only depending on that field, we
-      // can safely keep the number type for the field.
-      HType fieldSettersType = backend.fieldSettersTypeSoFar(node.element);
-      HType initializersType =
-          backend.typeFromInitializersSoFar(node.element);
-      HType fieldType = fieldSettersType.union(initializersType);
-      if (HType.NUMBER.union(fieldType) == HType.NUMBER &&
-          isSimpleFieldNumberComputation(node.value, node)) {
-        backend.updateFieldSetters(node.element, HType.NUMBER);
-      } else {
-        backend.updateFieldSetters(node.element, types[node.value]);
+        backend.registerFieldSetter(node, types);
       }
     }
     use(node.receiver);
     js.Expression receiver = pop();
     use(node.value);
     push(new js.Assignment(new js.PropertyAccess.field(receiver, name), pop()),
          node);
   }
 
   visitLocalGet(HLocalGet node) {
@@ skipping 18 matching lines @@
       List<js.Expression> data = <js.Expression>[];
       for (int i = 0; i < inputs.length; i++) {
         use(inputs[i]);
         data.add(pop());
       }
       push(new js.LiteralExpression.withData(code, data), node);
     }
   }
 
   visitForeignNew(HForeignNew node) {
-    int j = 0;
-    node.element.forEachInstanceField(
-      includeBackendMembers: true,
-      includeSuperMembers: true,
-      f: (ClassElement enclosingClass, Element member) {
-        backend.updateFieldInitializers(member, types[node.inputs[j]]);
-        j++;
-      });
     String jsClassReference = backend.namer.isolateAccess(node.element);
     List<HInstruction> inputs = node.inputs;
     // We can't use 'visitArguments', since our arguments start at input[0].
     List<js.Expression> arguments = <js.Expression>[];
     for (int i = 0; i < inputs.length; i++) {
       use(inputs[i]);
       arguments.add(pop());
     }
     // TODO(floitsch): jsClassReference is an Access. We shouldn't treat it
     // as if it was a string.
@@ skipping 1269 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }