anchor.diff:    }
   
     TypedefType asRaw() => super.asRaw();
  +
  +  accept(DartTypeVisitor visitor, var argument) {
  +    return visitor.visitTypedefType(this, argument);
  +  }
   }
   
   /**
  
positive.code:     t = t.unalias(compiler);
      s = s.unalias(compiler);
  
      if (t is VoidType) {
        return false;
      } else if (t is InterfaceType) {
        if (s is !InterfaceType) return false;
  
        bool checkTypeArguments(InterfaceType instance) {
          Link<DartType> tTypeArgs = instance.typeArguments;
          Link<DartType> sTypeArgs = s.typeArguments;
          while (!tTypeArgs.isEmpty) {
            assert(!sTypeArgs.isEmpty);
            if (!isSubtype(tTypeArgs.head, sTypeArgs.head)) {
              return false;
            }
            tTypeArgs = tTypeArgs.tail;
            sTypeArgs = sTypeArgs.tail;
          }
          assert(sTypeArgs.isEmpty);
          return true;
        }
  
        // TODO(johnniwinther): Currently needed since literal types like int,
        // double, bool etc. might not have been resolved yet.
        t.element.ensureResolved(compiler);
  
        InterfaceType instance = t.asInstanceOf(s.element);
        return instance != null && checkTypeArguments(instance);
      } else if (t is FunctionType) {
        if (identical(s.element, compiler.functionClass)) return true;
        if (s is !FunctionType) return false;
        FunctionType tf = t;
        FunctionType sf = s;
        Link<DartType> tps = tf.parameterTypes;
        Link<DartType> sps = sf.parameterTypes;
        while (!tps.isEmpty && !sps.isEmpty) {
          if (!isAssignable(tps.head, sps.head)) return false;
          tps = tps.tail;
          sps = sps.tail;
        }
        if (!tps.isEmpty || !sps.isEmpty) return false;
        if (!isAssignable(sf.returnType, tf.returnType)) return false;
        if (!sf.namedParameters.isEmpty) {
          // Since named parameters are globally ordered we can determine the
          // subset relation with a linear search for [:sf.NamedParameters:]
          // within [:tf.NamedParameters:].
          Link<SourceString> tNames = tf.namedParameters;
          Link<DartType> tTypes = tf.namedParameterTypes;
          Link<SourceString> sNames = sf.namedParameters;
          Link<DartType> sTypes = sf.namedParameterTypes;
          while (!tNames.isEmpty && !sNames.isEmpty) {
            if (sNames.head == tNames.head) {
              if (!isAssignable(tTypes.head, sTypes.head)) return false;
  
              sNames = sNames.tail;
              sTypes = sTypes.tail;
            }
            tNames = tNames.tail;
            tTypes = tTypes.tail;
          }
          if (!sNames.isEmpty) {
            // We didn't find all names.
            return false;
          }
        }
        if (!sf.optionalParameterTypes.isEmpty) {
          Link<DartType> tOptionalParameterType = tf.optionalParameterTypes;
          Link<DartType> sOptionalParameterType = sf.optionalParameterTypes;
          while (!tOptionalParameterType.isEmpty &&
                 !sOptionalParameterType.isEmpty) {
            if (!isAssignable(tOptionalParameterType.head,
                              sOptionalParameterType.head)) {
              return false;
            }
            sOptionalParameterType = sOptionalParameterType.tail;
            tOptionalParameterType = tOptionalParameterType.tail;
          }
          if (!sOptionalParameterType.isEmpty) {
            // We didn't find enough optional parameters.
            return false;
          }
        }
        return true;
      } else if (t is TypeVariableType) {
        if (s is !TypeVariableType) return false;
        return (identical(t.element, s.element));
      } else {
        throw 'internal error: unknown type kind';
      }
    }
  
    bool isAssignable(DartType r, DartType s) {
      return isSubtype(r, s) || isSubtype(s, r);
    }
  
  
  
negative.code:   bool get isRaw => true;
  
    DartType asRaw() => this;
  
    accept(DartTypeVisitor visitor, var argument);
  }
  
  /**
  