anchor.diff:    // TODO(vsm): Could be safe for num->double and once we represent boxed int and boxed double.
     bool get safe => false;
   
  -  String get message => '$expression ($baseType) must be unboxed to type $convertedType';
  +  String get message =>
  +      '$expression ($baseType) must be unboxed to type $convertedType';
   }
   
   class DownCast extends Conversion {
     DartType _newType;
   
  -  DownCast(TypeRules rules, Expression expression, this._newType) : super(rules, expression) {
  -    assert(_newType != baseType && (baseType.isDynamic || rules.isSubTypeOf(_newType, baseType)));
  +  DownCast(TypeRules rules, Expression expression, this._newType)
  +      : super(rules, expression) {
  +    assert(_newType != baseType && (baseType.isDynamic || rules
  +        .isSubTypeOf(_newType, baseType)));
     }
   
     DartType _getConvertedType() => _newType;
   
  -  String get message => '$expression ($baseType) will need runtime check to cast to type $convertedType';
  +  String get message =>
  +      '$expression ($baseType) will need runtime check to cast to type $convertedType';
   
     // Differentiate between Function down cast and non-Function down cast?  The former seems less likely
     // to actually succeed.
  -  logger.Level get level => (_newType is FunctionType) ? logger.Level.WARNING : super.level;
  +  logger.Level get level =>
  +      (_newType is FunctionType) ? logger.Level.WARNING : super.level;
   }
   
   class ClosureWrap extends Conversion {
     FunctionType _wrappedType;
   
  -  ClosureWrap(TypeRules rules, Expression expression, this._wrappedType) : super(rules, expression) {
  +  ClosureWrap(TypeRules rules, Expression expression, this._wrappedType)
  +      : super(rules, expression) {
       assert(baseType is FunctionType);
       assert(!rules.isSubTypeOf(_wrappedType, baseType));
     }
   
     DartType _getConvertedType() => _wrappedType;
   
  -  String get message => '$expression ($baseType) will need to be wrapped with a closure of type $convertedType';
  +  String get message =>
  +      '$expression ($baseType) will need to be wrapped with a closure of type $convertedType';
   
     logger.Level get level => logger.Level.WARNING;
   }
  
positive.code:       }
      }
  
      if (t1 is! FunctionType || t2 is! FunctionType)
        return false;
  
      // Functions
      // Note: it appears under the hood all Dart functions map to a class / hidden type
  
negative.code:           if (field.name == memberName) {
              // TODO(vsm): Is this the right test?
              bool syn = field.isSynthetic;
              if (!syn) {
                return new InvalidOverride(
                    node, element, type, subType, baseType, true);
              }
            }
          }
        }
      }
  
      if (type.isObject) return null;
  
      allowFieldOverride = allowFieldOverride == null ? false :
          allowFieldOverride;
      InvalidOverride base =
          findInvalidOverride(node, element, type.superclass, allowFieldOverride);
      if (base != null) return base;
  
      for (final parent in type.interfaces) {
        base = findInvalidOverride(node, element, parent, true);
        if (base != null) return base;
      }
  
      for (final parent in type.mixins) {
        base = findInvalidOverride(node, element, parent, true);
        if (base != null) return base;
      }
  
      return null;
    }
  
    void checkInvalidOverride(
        AstNode node, ExecutableElement element, InterfaceType type) {
      InvalidOverride invalid = findInvalidOverride(node, element, type);
      record(invalid);
    }
  