Start implementing checked mode and tools support for using it.

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 287 matching lines @@
 
   void startFunction(FunctionElement function,
                      FunctionExpression node) {
 
     ClosureTranslator translator =
         new ClosureTranslator(builder.compiler, builder.elements);
     closureData = translator.translate(node);
 
     FunctionParameters params = function.computeParameters(builder.compiler);
     params.forEachParameter((Element element) {
-      HParameterValue parameter = new HParameterValue(element);
+      HInstruction parameter = new HParameterValue(element);
       builder.add(parameter);
+      parameter = builder.potentiallyCheckType(parameter, element);
       directLocals[element] = parameter;
     });
 
     enterScope(node);
 
     // If the freeVariableMapping is not empty, then this function was a
     // nested closure that captures variables. Redirect the captured
     // variables to fields in the closure.
     closureData.freeVariableMapping.forEach((Element from, Element to) {
       redirectElement(from, to);
@@ skipping 704 matching lines @@
                     FunctionExpression node) {
     HBasicBlock block = graph.addNewBlock();
     open(graph.entry);
 
     localsHandler.startFunction(functionElement, node);
     close(new HGoto()).addSuccessor(block);
 
     open(block);
   }
 
+  HInstruction potentiallyCheckType(HInstruction original,
+                                    Element sourceElement) {
+    if (!compiler.enableTypeAssertions) return original;
+
+    Type type = sourceElement.computeType(compiler);
+    if (type === null) return original;
+    if (type.element === compiler.dynamicClass) return original;
+    if (type.element === compiler.objectClass) return original;
+
+    HType convertedType = new HType.fromBoundedType(type, compiler, true);
+
+    // TODO(ngeoffray): the factory method should never return null.
+    if (convertedType === null) {
+      return original;
+    }
+
+    // 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, true);
+    add(instruction);
+    return instruction;
+  }
+
   HGraph closeFunction() {
     // TODO(kasperl): Make this goto an implicit return.
     if (!isAborted()) close(new HGoto()).addSuccessor(graph.exit);
     graph.finalize();
     return graph;
   }
 
   HBasicBlock addNewBlock() {
     HBasicBlock block = graph.addNewBlock();
     // If adding a new block during building of an expression, it is due to
@@ skipping 744 matching lines @@
         add(target);
         add(new HInvokeStatic(selector, <HInstruction>[target, value]));
       } else {
         add(new HStaticStore(element, value));
       }
       stack.add(value);
     } else if (element === null || Elements.isInstanceField(element)) {
       HInstruction receiver = generateInstanceSendReceiver(send);
       generateInstanceSetterWithCompiledReceiver(send, receiver, value);
     } else {
-      localsHandler.updateLocal(element, value);
       stack.add(value);
       // If the value does not already have a name, give it here.
       if (value.sourceElement === null) {
         value.sourceElement = element;
       }
+      HInstruction checked = potentiallyCheckType(value, element);
+      if (checked !== value) {
+        pop();
+        stack.add(checked);
+      }
+      localsHandler.updateLocal(element, checked);
     }
   }
 
   visitOperatorSend(node) {
     assert(node.selector is Operator);
     Operator op = node.selector;
     if (const SourceString("[]") == op.source) {
       HStatic target = new HStatic(interceptors.getIndexInterceptor());
       add(target);
       visit(node.receiver);
@@ skipping 1430 matching lines @@
                                    <HInstruction>[target, input],
                                    HType.STRING));
     return builder.pop();
   }
 
   HInstruction result() {
     flushLiterals();
     return prefix;
   }
 }