Revert "Use interceptors for is-checks (version 2)."

pkg/compiler/lib/src/js_backend/codegen/codegen.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.
 
 library code_generator;
 
 import 'glue.dart';
 
 import '../../closure.dart' show ClosureClassElement;
 import '../../common/codegen.dart' show CodegenRegistry;
@@ skipping 339 matching lines @@
 
   @override
   js.Expression visitTypeOperator(tree_ir.TypeOperator node) {
     js.Expression value = visitExpression(node.value);
     List<js.Expression> typeArguments = visitExpressionList(node.typeArguments);
     DartType type = node.type;
     if (type is InterfaceType) {
       glue.registerIsCheck(type, registry);
       ClassElement clazz = type.element;
 
+      // Handle some special checks against classes that exist only in
+      // the compile-time class hierarchy, not at runtime.
+      // TODO(sra): Is this correct? The field tests are only valid with the
+      // precondition that [value] is an Array. They will crash on `null`.
+      if (clazz == glue.jsExtendableArrayClass) {
+        assert(node.isTypeTest);
+        return js.js(r'!#.fixed$length', <js.Expression>[value]);
+      } else if (clazz == glue.jsMutableArrayClass) {
+        assert(node.isTypeTest);
+        return js.js(r'!#.immutable$list', <js.Expression>[value]);
+      }
+
       if (glue.isStringClass(clazz)) {
         if (node.isTypeTest) {
           return js.js(r'typeof # === "string"', <js.Expression>[value]);
         }
         // TODO(sra): Implement fast cast via calling 'stringTypeCast'.
       } else if (glue.isBoolClass(clazz)) {
         if (node.isTypeTest) {
           return js.js(r'typeof # === "boolean"', <js.Expression>[value]);
         }
         // TODO(sra): Implement fast cast via calling 'boolTypeCast'.
@@ skipping 39 matching lines @@
       js.Expression typeValue = typeArguments.single;
 
       return buildStaticHelperInvocation(
           function,
           <js.Expression>[value, typeValue]);
     }
     return giveup(node, 'type check unimplemented for $type.');
   }
 
   @override
-  js.Expression visitGetTypeTestProperty(tree_ir.GetTypeTestProperty node) {
-    js.Expression object = visitExpression(node.object);
-    DartType dartType = node.dartType;
-    assert(dartType.isInterfaceType);
-    glue.registerIsCheck(dartType, registry);
-    js.Expression property = glue.getTypeTestTag(dartType);
-    return js.js(r'#.#', [object, property]);
-  }
-
-  @override
   js.Expression visitVariableUse(tree_ir.VariableUse node) {
     return buildVariableAccess(node.variable);
   }
 
   js.Expression buildVariableAccess(tree_ir.Variable variable) {
     return new js.VariableUse(getVariableName(variable));
   }
 
   @override
   js.Expression visitAssign(tree_ir.Assign node) {
@@ skipping 371 matching lines @@
       return buildStaticHelperInvocation(
           glue.getTypeArgumentByIndex(),
           [visitExpression(node.target), index],
           sourceInformation: node.sourceInformation);
     }
   }
 
   @override
   js.Expression visitTypeExpression(tree_ir.TypeExpression node) {
     List<js.Expression> arguments = visitExpressionList(node.arguments);
-    return glue.generateTypeRepresentation(node.dartType, arguments, registry);
+    return glue.generateTypeRepresentation(node.dartType, arguments);
   }
 
   js.Node handleForeignCode(tree_ir.ForeignCode node) {
     registry.registerStaticUse(node.dependency);
-    // TODO(sra): Should this be in CodegenRegistry?
-    glue.registerNativeBehavior(node.nativeBehavior, node);
     return node.codeTemplate.instantiate(visitExpressionList(node.arguments));
   }
 
   @override
   js.Expression visitForeignExpression(tree_ir.ForeignExpression node) {
     return handleForeignCode(node);
   }
 
   @override
   void visitForeignStatement(tree_ir.ForeignStatement node) {
@@ skipping 49 matching lines @@
       case BuiltinOperator.IsFalsy:
         return new js.Prefix('!', args[0]);
       case BuiltinOperator.IsNumber:
         return js.js('typeof # === "number"', args);
       case BuiltinOperator.IsNotNumber:
         return js.js('typeof # !== "number"', args);
       case BuiltinOperator.IsFloor:
         return js.js('Math.floor(#) === #', args);
       case BuiltinOperator.IsNumberAndFloor:
         return js.js('typeof # === "number" && Math.floor(#) === #', args);
-      case BuiltinOperator.IsFixedLengthJSArray:
-        // TODO(sra): Remove boolify (i.e. !!).
-        return js.js(r'!!#.fixed$length', args);
-      case BuiltinOperator.IsExtendableJSArray:
-        return js.js(r'!#.fixed$length', args);
-      case BuiltinOperator.IsModifiableJSArray:
-        return js.js(r'!#.immutable$list', args);
-      case BuiltinOperator.IsUnmodifiableJSArray:
-        // TODO(sra): Remove boolify (i.e. !!).
-        return js.js(r'!!#.immutable$list', args);
     }
   }
 
   /// The JS name of a built-in method.
   static final Map<BuiltinMethod, String> builtinMethodName =
     const <BuiltinMethod, String>{
       BuiltinMethod.Push: 'push',
       BuiltinMethod.Pop: 'pop',
   };
 
   @override
   js.Expression visitApplyBuiltinMethod(tree_ir.ApplyBuiltinMethod node) {
     String name = builtinMethodName[node.method];
     js.Expression receiver = visitExpression(node.receiver);
     List<js.Expression> args = visitExpressionList(node.arguments);
     return js.js('#.#(#)', [receiver, name, args]);
   }
 
   @override
   js.Expression visitAwait(tree_ir.Await node) {
     return new js.Await(visitExpression(node.input));
   }
 
   visitFunctionExpression(tree_ir.FunctionExpression node) {
     // FunctionExpressions are currently unused.
     // We might need them if we want to emit raw JS nested functions.
     throw 'FunctionExpressions should not be used';
   }
 }