Start implementing checked mode and tools support for using it.

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 {
   SsaCodeGeneratorTask(Compiler compiler) : super(compiler);
   String get name() => 'SSA code generator';
 
 
   String buildJavaScriptFunction(FunctionElement element,
@@ skipping 1049 matching lines @@
     HInstruction instruction = node.first;
     while (instruction != null) {
       if (instruction === node.last) {
         assignPhisOfAllSuccessors(node);
       }
 
       if (instruction is HGoto || instruction is HExit || instruction is HTry) {
         visit(instruction, JSPrecedence.STATEMENT_PRECEDENCE);
         return;
       } else if (!isGenerateAtUseSite(instruction)) {
-        if (instruction is !HIf && instruction is !HTypeGuard &&
-            instruction is !HLoopBranch && !isGeneratingExpression()) {
+        if (instruction is !HIf
+            && instruction is !HTypeGuard
+            && instruction is !HLoopBranch
+            && !isGeneratingExpression()) {
           addIndentation();
         }
         if (isGeneratingExpression()) {
           addExpressionSeparator();
         }
         if (instruction.usedBy.isEmpty()
             || instruction is HTypeGuard
             || instruction is HCheck) {
           visit(instruction, JSPrecedence.STATEMENT_PRECEDENCE);
         } else {
           define(instruction);
         }
         // Control flow instructions, and some other instructions,
         // know how to handle ';'.
-        if (instruction is !HControlFlow && instruction is !HTypeGuard &&
-            !isGeneratingExpression()) {
+        if (instruction is !HControlFlow
+            && instruction is !HTypeGuard
+            && !isGeneratingExpression()) {
           buffer.add(';\n');
         }
       } else if (instruction is HIf) {
         HIf hif = instruction;
         // The "if" is implementing part of a logical expression.
         // Skip directly forward to to its latest successor, since everything
         // in-between must also be generateAtUseSite.
         assert(hif.trueBranch.id < hif.falseBranch.id);
         visitBasicBlock(hif.falseBranch);
         return;
@@ skipping 779 matching lines @@
 
   void checkImmutableArray(HInstruction input) {
     beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
     buffer.add('!!');
     use(input, JSPrecedence.MEMBER_PRECEDENCE);
     buffer.add('.immutable\$list');
     endExpression(JSPrecedence.PREFIX_PRECEDENCE);
   }
 
   void checkExtendableArray(HInstruction input) {
-    compiler.unimplemented("check extendable array");
+    beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
+    buffer.add('!!');
+    use(input, JSPrecedence.MEMBER_PRECEDENCE);
+    buffer.add('.fixed\$length');
+    endExpression(JSPrecedence.PREFIX_PRECEDENCE);
   }
 
   void checkNull(HInstruction input) {
     beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
     use(input, JSPrecedence.EQUALITY_PRECEDENCE);
     buffer.add(" === (void 0)");
     endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
   }
 
   void checkFunction(HInstruction input, Element element) {
@@ skipping 121 matching lines @@
         buffer.add(".${name.slowToString()} === '${arguments.head}'");
         endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
       });
     }
     if (node.nullOk) {
       endExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
     }
   }
 
   void visitTypeConversion(HTypeConversion node) {
-    assert(isGenerateAtUseSite(node));
-    use(node.inputs[0], JSPrecedence.EXPRESSION_PRECEDENCE);
+    if (node.checked) {
+      Element element = node.type.computeType(compiler).element;
+      compiler.registerIsCheck(element);
+      SourceString helper;
+      String additionalArgument;
+      bool nativeCheck =
+          compiler.emitter.nativeEmitter.requiresNativeIsCheck(element);
+      beginExpression(JSPrecedence.CALL_PRECEDENCE);
+
+      if (element == compiler.stringClass) {
+        helper = const SourceString('stringTypeCheck');
+      } else if (element == compiler.doubleClass) {
+        helper = const SourceString('doubleTypeCheck');
+      } else if (element == compiler.numClass) {
+        helper = const SourceString('numTypeCheck');
+      } else if (element == compiler.boolClass) {
+        helper = const SourceString('boolTypeCheck');
+      } else if (element == compiler.functionClass || element.isTypedef()) {
+        helper = const SourceString('functionTypeCheck');
+      } else if (element == compiler.intClass) {
+        helper = const SourceString('intTypeCheck');
+      } else if (Elements.isStringSupertype(element, compiler)) {
+        if (nativeCheck) {
+          helper = const SourceString('stringSuperNativeTypeCheck');
+        } else {
+          helper = const SourceString('stringSuperTypeCheck');
+        }
+      } else if (element === compiler.listClass) {
+        helper = const SourceString('listTypeCheck');
+      } else {
+        additionalArgument = compiler.namer.operatorIs(element);
+        if (Elements.isListSupertype(element, compiler)) {
+          if (nativeCheck) {
+            helper = const SourceString('listSuperNativeTypeCheck');
+          } else {
+            helper = const SourceString('listSuperTypeCheck');
+          }
+        } else if (nativeCheck) {
+          helper = const SourceString('callTypeCheck');
+        } else {
+          helper = const SourceString('propertyTypeCheck');
+        }
+      }
+      Element helperElement = compiler.findHelper(helper);
+      compiler.registerStaticUse(helperElement);
+      buffer.add(compiler.namer.isolateAccess(helperElement));
+      buffer.add('(');
+      use(node.inputs[0], JSPrecedence.EXPRESSION_PRECEDENCE);
+      if (additionalArgument !== null) buffer.add(", '$additionalArgument'");
+      buffer.add(')');
+      endExpression(JSPrecedence.CALL_PRECEDENCE);
+    } else {
+      use(node.inputs[0], expectedPrecedence);
+    }
   }
 }
 
 class SsaOptimizedCodeGenerator extends SsaCodeGenerator {
   SsaOptimizedCodeGenerator(compiler, work, parameters, parameterNames)
     : super(compiler, work, parameters, parameterNames);
 
   void beginGraph(HGraph graph) {}
   void endGraph(HGraph graph) {}
 
@@ skipping 387 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
     if (labeledBlockInfo.body.start.hasGuards()) {
       endBailoutSwitch();
     }
   }
 }