Dart2dart rename unresolved getters & Make IsCheck not be a primitive

sdk/lib/_internal/compiler/implementation/ir/ir_nodes.dart

 // Copyright (c) 2013, 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.
 
 // IrNodes are kept in a separate library to have precise control over their
 // dependencies on other parts of the system.
 library dart2js.ir_nodes;
 
 import '../dart2jslib.dart' as dart2js show Constant, ConstructedConstant,
   StringConstant, ListConstant, MapConstant;
@@ skipping 219 matching lines @@
       : continuation = new Reference(cont),
         arguments = _referenceList(args) {
     assert(target.isErroneous || target.isConstructor);
     assert(target.isErroneous || type.isDynamic ||
            type.element == target.enclosingElement);
   }
 
   accept(Visitor visitor) => visitor.visitInvokeConstructor(this);
 }
 
-class AsCast extends Expression {
+/// "as" casts and "is" checks.
+// We might want to turn "is"-checks into a [Primitive] as it can never diverge.
+// But then we need to special-case for is-checks with an erroneous .type as
+// these will throw.
+class TypeOperator extends Expression {
   final Reference receiver;
   final DartType type;
   final Reference continuation;
+  final String operator;
 
-  AsCast(Primitive receiver, this.type, Continuation cont)
+  TypeOperator(this.operator,
+                Primitive receiver,
+                this.type,
+                Continuation cont)
       : this.receiver = new Reference(receiver),
-        this.continuation = new Reference(cont);
+        this.continuation = new Reference(cont) {
+    assert(operator == "is" || operator == "as");
+  }
 
-  accept(Visitor visitor) => visitor.visitAsCast(this);
+  accept(Visitor visitor) => visitor.visitTypeOperator(this);
 }
 
 /// Invoke [toString] on each argument and concatenate the results.
 class ConcatenateStrings extends Expression {
   final Reference continuation;
   final List<Reference> arguments;
 
   ConcatenateStrings(Continuation cont, List<Definition> args)
       : continuation = new Reference(cont),
         arguments = _referenceList(args);
@@ skipping 180 matching lines @@
 
 /// Create a non-recursive function.
 class CreateFunction extends Primitive {
   final FunctionDefinition definition;
 
   CreateFunction(this.definition);
 
   accept(Visitor visitor) => visitor.visitCreateFunction(this);
 }
 
-class IsCheck extends Primitive {
-  final Reference receiver;
-  final DartType type;
-
-  dart2js.Constant get constant => null;
-
-  IsCheck(Primitive receiver, this.type)
-      : this.receiver = new Reference(receiver);
-
-  accept(Visitor visitor) => visitor.visitIsCheck(this);
-}
-
 class Parameter extends Primitive {
   Parameter(Element element) {
     super.hint = element;
   }
 
   accept(Visitor visitor) => visitor.visitParameter(this);
 }
 
 /// Continuations are normally bound by 'let cont'.  A continuation with no
 /// parameter (or body) is used to represent a function's return continuation.
@@ skipping 50 matching lines @@
   // Expressions.
   T visitLetPrim(LetPrim node) => visitExpression(node);
   T visitLetCont(LetCont node) => visitExpression(node);
   T visitInvokeStatic(InvokeStatic node) => visitExpression(node);
   T visitInvokeContinuation(InvokeContinuation node) => visitExpression(node);
   T visitInvokeMethod(InvokeMethod node) => visitExpression(node);
   T visitInvokeSuperMethod(InvokeSuperMethod node) => visitExpression(node);
   T visitInvokeConstructor(InvokeConstructor node) => visitExpression(node);
   T visitConcatenateStrings(ConcatenateStrings node) => visitExpression(node);
   T visitBranch(Branch node) => visitExpression(node);
-  T visitAsCast(AsCast node) => visitExpression(node);
+  T visitTypeOperator(TypeOperator node) => visitExpression(node);
   T visitSetClosureVariable(SetClosureVariable node) => visitExpression(node);
   T visitDeclareFunction(DeclareFunction node) => visitExpression(node);
 
   // Definitions.
   T visitLiteralList(LiteralList node) => visitPrimitive(node);
   T visitLiteralMap(LiteralMap node) => visitPrimitive(node);
-  T visitIsCheck(IsCheck node) => visitPrimitive(node);
   T visitConstant(Constant node) => visitPrimitive(node);
   T visitThis(This node) => visitPrimitive(node);
   T visitReifyTypeVar(ReifyTypeVar node) => visitPrimitive(node);
   T visitCreateFunction(CreateFunction node) => visitPrimitive(node);
   T visitGetClosureVariable(GetClosureVariable node) => visitPrimitive(node);
   T visitParameter(Parameter node) => visitPrimitive(node);
   T visitContinuation(Continuation node) => visitDefinition(node);
 
   // Conditions.
   T visitIsTrue(IsTrue node) => visitCondition(node);
@@ skipping 230 matching lines @@
 
   void visitLetCont(LetCont node) {
     visit(node.continuation);
     visit(node.body);
   }
 
   void visitInvokeStatic(InvokeStatic node) {
     node.arguments.forEach(visitReference);
   }
 
-  void visitAsCast(AsCast node) {
-    visitReference(node.receiver);
-  }
-
   void visitInvokeContinuation(InvokeContinuation node) {
     node.arguments.forEach(visitReference);
   }
 
   void visitInvokeMethod(InvokeMethod node) {
     visitReference(node.receiver);
     node.arguments.forEach(visitReference);
   }
 
   void visitInvokeSuperMethod(InvokeSuperMethod node) {
@@ skipping 16 matching lines @@
     node.values.forEach(visitReference);
   }
 
   void visitLiteralMap(LiteralMap node) {
     for (int i = 0; i < node.keys.length; ++i) {
       visitReference(node.keys[i]);
       visitReference(node.values[i]);
     }
   }
 
-  void visitIsCheck(IsCheck node) {
+  void visitTypeOperator(TypeOperator node) {
     visitReference(node.receiver);
   }
 
   void visitConstant(Constant node) {
   }
 
   void visitThis(This node) {
   }
 
   void visitReifyTypeVar(ReifyTypeVar node) {
@@ skipping 29 matching lines @@
     for (int i = node.parameters.length - 1; i >= 0; --i) {
       release(node.parameters[i]);
     }
   }
 
   void visitIsTrue(IsTrue node) {
     visitReference(node.value);
   }
 
 }