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 1055 matching lines @@
 
     localsHandler.startFunction(functionElement, node);
     close(new HGoto()).addSuccessor(block);
 
     open(block);
   }
 
   HInstruction potentiallyCheckType(HInstruction original,
                                     Element sourceElement) {
     if (!compiler.enableTypeAssertions) return original;
+    return convertType(original, sourceElement, HTypeConversion.CHECKED);
+  }
 
+  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;
 
     HType convertedType = new HType.fromBoundedType(type, compiler, true);
 
     // 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);
+        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);
+      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 1458 matching lines @@
   void visitNodeList(NodeList node) {
      node.visitChildren(this);
   }
 
   HInstruction concat(HInstruction left, HInstruction right) {
     HInstruction instruction = new HStringConcat(left, right, node);
     builder.add(instruction);
     return instruction;
   }
 }