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:     }
  
      bool hasFreeFormal(t) {
        if (partials.containsKey(t)) return true;
        // Generic classes and typedefs.
        var typeArgs = getGenericArgs(t);
  
negative.code: 
  /// Constructs a normalized version of a type.
  ///
  /// Used for type object identity. Normalization requires us to return a
  /// canonicalized version of the input with all legacy wrappers removed.
  Type _canonicalizeNormalizedTypeObject(type) {
    assert(type is! LegacyType);
    // 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 term.
    Object normalizeHelper(a) => unwrapType(wrapType(a));
  
    if (type is FunctionType) {
      var normReturnType = normalizeHelper(type.returnType);
      var normArgs = type.args.map(normalizeHelper).toList();
      if (JS<bool>('!', '#.Object.keys(#).length === 0', global_, type.named) &&
          JS<bool>('!', '#.Object.keys(#).length === 0', global_,
              type.requiredNamed)) {
        if (type.optionals.isEmpty) {
          var normType = fnType(normReturnType, normArgs);
          return wrapType(normType, isNormalized: true);
        }
        var normOptionals = type.optionals.map(normalizeHelper).toList();
        var normType = fnType(normReturnType, normArgs, normOptionals);
        return wrapType(normType, isNormalized: true);
      }
      var normNamed = JS('', '{}');
      _transformJSObject(type.named, normNamed, normalizeHelper);
      var normRequiredNamed = JS('', '{}');
      _transformJSObject(type.requiredNamed, normRequiredNamed, normalizeHelper);
      var normType =
          fnType(normReturnType, normArgs, normNamed, normRequiredNamed);
      return wrapType(normType, isNormalized: true);
    }
    var args = getGenericArgs(type);
    var normType;
    if (args == null || args.isEmpty) {
      normType = type;
    } else {
      var genericClass = getGenericClass(type);
      var normArgs = args.map(normalizeHelper).toList();
      normType = JS('!', '#(...#)', genericClass, normArgs);
    }
    return wrapType(normType, isNormalized: true);
  }
  
  /// Generates new values by applying [transform] to the keys of [srcObject],
  /// storing them in [dstObject].
  void _transformJSObject(srcObject, dstObject, Function transform) {
    for (Object key in JS('!', '#.Object.keys(#)', global_, srcObject)) {
      JS('', '#[#] = #', dstObject, key, transform(key));
    }
  }
  
  /// The symbol used to store the cached `Type` object associated with a class.
  