anchor.diff:    var result = isNormalized
         ? _Type(type)
         : (type is LegacyType
  -          ? _wrapType(type.type, false)
  +          ? wrapType(type.type)
             : _canonicalizeNormalizedTypeObject(type));
     JS('', '#[#] = #', type, _typeObject, result);
     return result;
  
positive.code: 
  /// Constructs a normalized version of a type.
  ///
  /// Used for type object identity. Currently only removes legacy wrappers,
  /// ignoring other normalization operations.
  Type _canonicalizeNormalizedTypeObject(type) {
    assert(type is! LegacyType);
    var args = getGenericArgs(type);
    var normType;
    if (args == null || args.isEmpty) {
      normType = type;
    } else {
      var genericClass = getGenericClass(type);
      // We don't call _canonicalizeNormalizedTypeObject recursively but call wrap
      // + unwrap to handle legacy types automatically and force caching the
      // canonicalized type under the _typeObject cache property directly. This
      // way we ensure we always use the canonical normalized instance for each
      // type parameter.
      var normArgs = args.map((a) => unwrapType(wrapType(a))).toList();
      normType = JS('!', '#(...#)', genericClass, normArgs);
    }
    return _wrapType(normType, true);
  }
  
  /// The symbol used to store the cached `Type` object associated with a class.
  
negative.code:     }
  
      bool hasFreeFormal(t) {
        // Ignore nullability wrappers.
        if (_isLegacy(t) || _isNullable(t)) {
          return hasFreeFormal(JS<Type>('', '#.type', t));
        }
        if (partials.containsKey(t)) return true;
        // Generic classes and typedefs.
        var typeArgs = getGenericArgs(t);
  