anchor.diff:  
   /// Implementation that uses other [DartType]s when doing type comparisons.
   class _LibraryMetadataTypes extends MetadataTypes {
  +  final bool _checkSubTypes;
     final LibraryElement _metadataLibrary;
   
  -  _LibraryMetadataTypes(this._metadataLibrary) : super._();
  +  _LibraryMetadataTypes(this._metadataLibrary, {bool checkSubTypes: false})
  +      : _checkSubTypes = checkSubTypes,
  +        super._();
   
     @override
     bool _isA(DartType staticType, Type runtimeType) {
  +    if (!_checkSubTypes) {
  +      return _isExactly(staticType, runtimeType);
  +    }
       final comparisonType = _metadataLibrary.getType('$runtimeType').type;
       return staticType.isSubtypeOf(comparisonType);
     }
  
positive.code: 
  /// Implementation that uses runtime reflection to do type comparisons.
  class _MirrorsMetadataTypes extends MetadataTypes {
    const _MirrorsMetadataTypes() : super._();
  
    @override
    bool _isA(DartType staticType, Type runtimeType) {
      final element = staticType.element;
      if (element is ClassElement) {
        return element.allSupertypes.any((t) => matchTypes(runtimeType, t));
  
negative.code: /// An abstraction around comparing types statically (at compile-time).
  abstract class MetadataTypes {
    /// Creates a [MetadataTypes] that uses runtime reflection.
    const factory MetadataTypes.withMirrors({
      bool checkSubTypes,
    }) = _MirrorsMetadataTypes;
  
    /// Creates a [MetadataTypes] by retrieving exact types from [resolver].
    ///
    /// With _analysis summaries_ this should be a relatively cheap operation but
    /// the resulting [MetadataTypes] class should still be cached whenever
    /// possible.
    factory MetadataTypes.fromResolver(
      Resolver resolver, {
      bool checkSubTypes,
    }) {
      final srcMetadata = new AssetId('angular2', 'src/meta/core/metadata.dart');
      final libMetadata = resolver.getLibrary(srcMetadata);
      return new _LibraryMetadataTypes(libMetadata);
  