anchor.diff:  
     bool record(StaticInfo info) {
       if (info != null) {
  -      if (info.level >= logger.Level.SEVERE)
  -        failure = true;
  -      if (!infoMap.containsKey(info.node))
  +      if (info.level >= logger.Level.SEVERE) failure = true;
  +      if (!infoMap.containsKey(info.node)) {
           infoMap[info.node] = new List<StaticInfo>();
  +      }
         infoMap[info.node].add(info);
         log.log(info.level, info.message, info.node);
         return true;
  
positive.code:   bool isSubTypeOf(DartType t1, DartType t2) {
      // Primitives are standalone types.  Unless boxed, they do not subtype
      // Object and are not subtyped by dynamic.
      if (isPrimitive(t1) || isPrimitive(t2))
        return isPrimitiveEquals(t1, t2);
  
      if (t1 is TypeParameterType)
        t1 = provider.dynamicType;
      if (t2 is TypeParameterType)
        t2 = provider.dynamicType;
  
      if (t1 == t2)
        return true;
  
      // Null can be assigned to anything else.
      // FIXME: Can this be anything besides null?
      if (t1.isBottom)
        return true;
  
      // Trivially true for non-primitives.
      if (t2 == provider.objectType)
        return true;
  
      // Trivially false.
      if (t1 == provider.objectType && t2 != provider.dynamicType)
        return false;
  
      // How do we handle dynamic?  In Dart, dynamic subtypes everything.
      // This is somewhat counterintuitive - subtyping usually narrows.
      // Here we treat dynamic essentially as Object.
      if (isDynamic(t1))
        return false;
      if (isDynamic(t2))
        return true;
  
      // "Traditional" name-based subtype check.
      // FIXME: What happens with classes that implement Function?
  
negative.code:         assert(type == provider.doubleType);
          return new NumericConversion(this, expr);
        } else {
          if (exprType is FunctionType &&
              type is FunctionType &&
              isWrappableFunctionType(exprType, type)) {
            return new ClosureWrap(this, expr, type);
          } else {
            return new StaticTypeError(this, expr, type);
  