anchor.diff:  }
   
   /**
  - * Extracts the type arguments from a type representation. The result is a
  - * JavaScript array or [:null:].
  - */
  -getArguments(var type) {
  -  return isJsArray(type) ? JS('var', r'#.slice(1)', type) : null;
  -}
  -
  -/**
  - * Checks whether the type represented by the type representation [s] is a
  - * subtype of the type represented by the type representation [t].
  + * Check whether the type represented by [s] is a subtype of the type
  + * represented by [t].
    *
  - * See the comment in the beginning of this file for a description of type
  - * representations.
  + * Type representations can be:
  + *  1) a JavaScript constructor for a class C: the represented type is the raw
  + *     type C.
  + *  2) a Dart object: this is the interceptor instance for a native type.
  + *  3) a JavaScript object: this represents a class for which there is no
  + *     JavaScript constructor, because it is only used in type arguments or it
  + *     is native. The represented type is the raw type of this class.
  + *  4) a JavaScript array: the first entry is of type 1, 2 or 3 and contains the
  + *     subtyping flags and the substitution of the type and the rest of the
  + *     array are the type arguments.
  + *  5) [:null:]: the dynamic type.
    */
   bool isSubtype(var s, var t) {
     // If either type is dynamic, [s] is a subtype of [t].
  -  if (isNull(s) || isNull(t)) return true;
  +  if (JS('bool', '# == null', s) || JS('bool', '# == null', t)) return true;
     // Subtyping is reflexive.
  -  if (isIdentical(s, t)) return true;
  +  if (JS('bool', '# === #', s, t)) return true;
     // Get the object describing the class and check for the subtyping flag
     // constructed from the type of [t].
  -  var typeOfS = isJsArray(s) ? getIndex(s, 0) : s;
  -  var typeOfT = isJsArray(t) ? getIndex(t, 0) : t;
  +  var typeOfS = s is JSArray ? s[0] : s;
  +  var typeOfT = t is JSArray ? t[0] : t;
     // TODO(johnniwinther): replace this with the real function subtype test.
     if (JS('bool', '#.func', s) == true || JS('bool', '#.func', t) == true ) {
       return true;
     }
     // Check for a subtyping flag.
     var test = '${JS_OPERATOR_IS_PREFIX()}${runtimeTypeToString(typeOfT)}';
  -  if (isNull(getField(typeOfS, test))) return false;
  +  if (getField(typeOfS, test) == null) return false;
     // Get the necessary substitution of the type arguments, if there is one.
     var substitution;
  -  if (isNotIdentical(typeOfT, typeOfS)) {
  +  if (JS('bool', '# !== #', typeOfT, typeOfS)) {
       var field = '${JS_OPERATOR_AS_PREFIX()}${runtimeTypeToString(typeOfT)}';
       substitution = getField(typeOfS, field);
     }
  
positive.code:   return allDynamic ? '' : '<$buffer>';
  }
  
  /**
   * Returns a human-readable representation of the type of [object].
   */
  String getRuntimeTypeString(var object) {
    String className = isJsArray(object) ? 'List' : getClassName(object);
    var typeInfo = JS('var', r'#.$builtinTypeInfo', object);
    return "$className${joinArguments(typeInfo, 0)}";
  }
  
negative.code: // 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.
  
  part of _js_helper;
  
  setRuntimeTypeInfo(target, typeInfo) {
    assert(typeInfo == null || typeInfo is JSArray);
    // We have to check for null because factories may return null.
    if (target != null) JS('var', r'#.$builtinTypeInfo = #', target, typeInfo);
  }
  
  getRuntimeTypeInfo(target) {
    if (target == null) return null;
    return JS('var', r'#.$builtinTypeInfo', target);
  }
  
  getRuntimeTypeArgument(target, substitution, index) {
    var arguments = substitute(substitution, getRuntimeTypeInfo(target));
    return (arguments == null) ? null : getField(arguments, index);
  }
  
  class TypeImpl implements Type {
    final String _typeName;
  
    TypeImpl(this._typeName);
  
    toString() => _typeName;
  
    // TODO(ahe): This is a poor hashCode as it collides with its name.
    int get hashCode => _typeName.hashCode;
  