dart2js cps: Type casts and related changes to type propagation.

tests/compiler/dart2js/backend_dart/sexpr_unstringifier.dart

 // Copyright (c) 2014, 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.
 
 // SExpressionUnstringifier implements the inverse operation to
 // [SExpressionStringifier].
 
 library sexpr_unstringifier;
 
 import 'package:compiler/src/constants/expressions.dart';
@@ skipping 117 matching lines @@
   static const String DECLARE_FUNCTION = "DeclareFunction";
   static const String INVOKE_CONSTRUCTOR = "InvokeConstructor";
   static const String INVOKE_CONTINUATION = "InvokeContinuation";
   static const String INVOKE_STATIC = "InvokeStatic";
   static const String INVOKE_METHOD_DIRECTLY = "InvokeMethodDirectly";
   static const String INVOKE_METHOD = "InvokeMethod";
   static const String LET_PRIM = "LetPrim";
   static const String LET_CONT = "LetCont";
   static const String LET_MUTABLE = "LetMutable";
   static const String SET_MUTABLE_VARIABLE = "SetMutableVariable";
-  static const String TYPE_OPERATOR = "TypeOperator";
+  static const String TYPE_CAST = "TypeCast";
   static const String SET_STATIC = "SetStatic";
   static const String GET_LAZY_STATIC = "GetLazyStatic";
+  static const String UNREACHABLE = "Unreachable";
 
   // Primitives
   static const String CONSTANT = "Constant";
   static const String CREATE_FUNCTION = "CreateFunction";
   static const String GET_MUTABLE_VARIABLE = "GetMutableVariable";
   static const String LITERAL_LIST = "LiteralList";
   static const String LITERAL_MAP = "LiteralMap";
   static const String REIFY_TYPE_VAR = "ReifyTypeVar";
   static const String GET_STATIC = "GetStatic";
+  static const String TYPE_TEST = "TypeTest";
 
   // Other
   static const String FUNCTION_DEFINITION = "FunctionDefinition";
   static const String IS_TRUE = "IsTrue";
 
   // Constants
   static const String BOOL = "Bool";
   static const String DOUBLE = "Double";
   static const String INT = "Int";
   static const String NULL = "Null";
@@ skipping 80 matching lines @@
       case INVOKE_METHOD_DIRECTLY:
         return parseInvokeMethodDirectly();
       case LET_PRIM:
         return parseLetPrim();
       case LET_CONT:
         return parseLetCont();
       case LET_MUTABLE:
         return parseLetMutable();
       case SET_MUTABLE_VARIABLE:
         return parseSetMutableVariable();
-      case TYPE_OPERATOR:
-        return parseTypeOperator();
+      case TYPE_CAST:
+        return parseTypeCast();
       case SET_STATIC:
         return parseSetStatic();
       case GET_LAZY_STATIC:
         return parseGetLazyStatic();
+      case UNREACHABLE:
+        return parseUnreachable();
       default:
         assert(false);
     }
 
     return null;
   }
 
   /// (prim1 prim2 ... primn)
   List<Primitive> parsePrimitiveList() {
     tokens.consumeStart();
@@ skipping 280 matching lines @@
     Primitive value = name2variable[tokens.read()];
     assert(value != null);
 
     Expression body = parseExpression();
 
     tokens.consumeEnd();
     return new SetMutableVariable(local, value)
                   ..plug(body);
   }
 
-  /// (TypeOperator operator recv type cont)
-  TypeOperator parseTypeOperator() {
-    tokens.consumeStart(TYPE_OPERATOR);
+  /// (TypeCast value type args cont)
+  TypeCast parseTypeCast() {
+    tokens.consumeStart(TYPE_CAST);
 
-    String operator = tokens.read();
-
-    Primitive recv = name2variable[tokens.read()];
-    assert(recv != null);
+    Primitive value = name2variable[tokens.read()];
+    assert(value != null);
 
     dart_types.DartType type = new DummyNamedType(tokens.read());
 
     List<ir.Primitive> typeArguments = parsePrimitiveList();
 
     Continuation cont = name2variable[tokens.read()];
     assert(cont != null);
 
     tokens.consumeEnd();
-    return new TypeOperator(recv, type, typeArguments, cont,
-                            isTypeTest: operator == 'is');
+    return new TypeCast(value, type, typeArguments, cont);
+  }
+
+  /// (TypeTest value type args)
+  TypeTest parseTypeTest() {
+    tokens.consumeStart(TYPE_TEST);
+
+    Primitive value = name2variable[tokens.read()];
+    assert(value != null);
+
+    dart_types.DartType type = new DummyNamedType(tokens.read());
+
+    List<ir.Primitive> typeArguments = parsePrimitiveList();
+
+    tokens.consumeEnd();
+    return new TypeTest(value, type, typeArguments);
   }
 
   /// (SetStatic field value body)
   SetStatic parseSetStatic() {
     tokens.consumeStart(SET_STATIC);
 
     Element fieldElement = new DummyElement(tokens.read());
     Primitive value = name2variable[tokens.read()];
     assert(value != null);
     Expression body = parseExpression();
 
     tokens.consumeEnd();
     return new SetStatic(fieldElement, value, null)..plug(body);
   }
 
   /// (GetLazyStatic field cont)
   GetLazyStatic parseGetLazyStatic() {
     tokens.consumeStart(GET_LAZY_STATIC);
 
     Element fieldElement = new DummyElement(tokens.read());
     Continuation cont = name2variable[tokens.read()];
     assert(cont != null);
 
     tokens.consumeEnd();
     return new GetLazyStatic(fieldElement, cont, null);
   }
 
+  /// (Unreachable)
+  Unreachable parseUnreachable() {
+    tokens.consumeStart(UNREACHABLE);
+    tokens.consumeEnd();
+    return new Unreachable();
+  }
+
   /// (LetPrim (name primitive) body)
   LetPrim parseLetPrim() {
     tokens.consumeStart(LET_PRIM);
 
     // (name
     tokens.consumeStart();
     String name = tokens.read();
 
     // primitive)
     Primitive primitive = parsePrimitive();
@@ skipping 18 matching lines @@
       case GET_MUTABLE_VARIABLE:
         return parseGetMutableVariable();
       case LITERAL_LIST:
         return parseLiteralList();
       case LITERAL_MAP:
         return parseLiteralMap();
       case REIFY_TYPE_VAR:
         return parseReifyTypeVar();
       case GET_STATIC:
         return parseGetStatic();
+      case TYPE_TEST:
+        return parseTypeTest();
       default:
         assert(false);
     }
 
     return null;
   }
 
   /// (Constant (constant))
   Constant parseConstant() {
     tokens.consumeStart(CONSTANT);
@@ skipping 116 matching lines @@
   /// (GetStatic field)
   GetStatic parseGetStatic() {
     tokens.consumeStart(GET_STATIC);
 
     Element field = new DummyElement(tokens.read());
 
     tokens.consumeEnd();
     return new GetStatic(field, null);
   }
 }