Implement 'as' operator.

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 1074 matching lines @@
     params.forEachParameter((Element element) {
       HInstruction newParameter = potentiallyCheckType(
           localsHandler.directLocals[element], element);
       localsHandler.directLocals[element] = newParameter;
     });
   }
 
   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) {
     Type type = sourceElement.computeType(compiler);
     if (type === null) return original;
-    if (type.element === compiler.dynamicClass) return original;
-    if (type.element === compiler.objectClass) return original;
+    // Casts affect static type warnings. They can't be omitted yet.
+    if (kind != HTypeConversion.CAST_TYPE_CHECK) {
+      if (type.element === compiler.dynamicClass) return original;
+      if (type.element === compiler.objectClass) return original;
+    }
 
-    HType convertedType = new HType.fromBoundedType(type, compiler, true);
+    // 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.checkedModeCheck(convertedType, original);
+        new HTypeConversion(convertedType, original, kind);
     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;
   }
@@ skipping 850 matching lines @@
           instruction = new HIs.withTypeInfoCall(type, expression, typeInfo);
         } else {
           instruction = new HIs(type, expression);
         }
         if (isNot) {
           add(instruction);
           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();
+      Type type = elements.getType(typeAnnotation);
+      HInstruction converted = convertType(expression, type.element,
+                                           HTypeConversion.CAST_TYPE_CHECK);
+      stack.add(converted);
     } else {
       visit(node.receiver);
       visit(node.argumentsNode);
       var right = pop();
       var left = pop();
       visitBinary(left, op, right);
     }
   }
 
   void addDynamicSendArgumentsToList(Send node, List<HInstruction> list) {
@@ skipping 1473 matching lines @@
   void visitNodeList(NodeList node) {
      node.visitChildren(this);
   }
 
   HInstruction concat(HInstruction left, HInstruction right) {
     HInstruction instruction = new HStringConcat(left, right, diagnosticNode);
     builder.add(instruction);
     return instruction;
   }
 }