Improvements for checked mode: check when intializing fields, and when assigning to fields.

lib/compiler/implementation/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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 1180 matching lines @@
     // initializers and constructor bodies.
     List<FunctionElement> constructors = <FunctionElement>[functionElement];
     buildInitializers(functionElement, constructors, fieldValues);
 
     // Call the JavaScript constructor with the fields as argument.
     List<HInstruction> constructorArguments = <HInstruction>[];
     classElement.forEachInstanceField(
         includeBackendMembers: true,
         includeSuperMembers: true,
         f: (ClassElement enclosingClass, Element member) {
-      constructorArguments.add(fieldValues[member]);
+      constructorArguments.add(
+          potentiallyCheckType(fieldValues[member], member));
     });
 
     HForeignNew newObject = new HForeignNew(classElement, constructorArguments);
     add(newObject);
 
     // If the class has type variables, create the runtime type
     // information with the type parameters provided.
     if (!classElement.typeVariables.isEmpty()) {
       List<String> typeVariables = <String>[];
       List<HInstruction> rtiInputs = <HInstruction>[];
@@ skipping 121 matching lines @@
         HParameterValue param = new HParameterValue(typeVariable.element);
         add(param);
         localsHandler.directLocals[typeVariable.element] = param;
       });
     }
   }
 
   HInstruction potentiallyCheckType(HInstruction original,
                                     Element sourceElement) {
     if (!compiler.enableTypeAssertions) return original;
-    return convertType(original, sourceElement,
-                       HTypeConversion.CHECKED_MODE_CHECK);
-  }
-
-  HInstruction convertType(HInstruction original,
-                           Element sourceElement,
-                           int kind) {
-    DartType type = sourceElement.computeType(compiler);
-    if (type === null) return original;
-    if (type.element === compiler.dynamicClass) return original;
-    if (type.element === compiler.objectClass) return original;
-
-    // If the original can't be null, type conversion also can't produce null.
-    bool canBeNull = original.guaranteedType.canBeNull();
-    HType convertedType =
-        new HType.fromBoundedType(type, compiler, canBeNull);
-
-    // No need to convert if we know the instruction has
-    // [convertedType] as a bound.
-    if (original.guaranteedType == convertedType) {
-      return original;
-    }
-
-    HInstruction instruction =
-        new HTypeConversion(convertedType, original, kind);
-    add(instruction);
-    return instruction;
+    HInstruction other = original.convertType(
+        compiler, sourceElement, HTypeConversion.CHECKED_MODE_CHECK);
+    if (other != original) add(other);
+    return other;
   }
 
   HGraph closeFunction() {
     // TODO(kasperl): Make this goto an implicit return.
     if (!isAborted()) close(new HGoto()).addSuccessor(graph.exit);
     graph.finalize();
     return graph;
   }
 
   HBasicBlock addNewBlock() {
@@ skipping 807 matching lines @@
           instruction = new HNot(instruction);
         }
         push(instruction);
       }
     } else if (const SourceString("as") == op.source) {
       visit(node.receiver);
       HInstruction expression = pop();
       Node argument = node.arguments.head;
       TypeAnnotation typeAnnotation = argument.asTypeAnnotation();
       DartType type = elements.getType(typeAnnotation);
-      HInstruction converted = convertType(expression, type.element,
-                                           HTypeConversion.CAST_TYPE_CHECK);
+      HInstruction converted = expression.convertType(
+          compiler, type.element, HTypeConversion.CAST_TYPE_CHECK);
+      if (converted != expression) add(converted);
       stack.add(converted);
     } else {
       visit(node.receiver);
       visit(node.argumentsNode);
       var right = pop();
       var left = pop();
       visitBinary(left, op, right);
     }
   }
 
@@ skipping 1817 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }