anchor.diff:          );
         });
         test('with nested concrete type arguments', () async {
  -        final example = await resolveClass('''
  -          import '$typedImport';
  +        final typeLink = await parse('''
             const typed = Typed<List<List<String>>>();
   
             @typed
             class Example {}
           ''');
  -        final typedReader = TypedReader(example);
  -        final typedValue = example.metadata.first.computeConstantValue();
  -        expect(
  -          typedReader.parse(typedValue),
  +        expect(
  +          typeLink,
             TypeLink('List', 'dart:core', [
               TypeLink('List', 'dart:core', [
                 TypeLink('String', 'dart:core'),
  
positive.code:         );
        });
        test('with nested Typed argument', () async {
          final example = await resolveClass('''
            import '$typedImport';
            const typed = Typed<List>.of([Typed<Map>.of([String, #X])]);
  
            @typed
            class Example<X> {}
          ''');
          final typedReader = TypedReader(example);
          final typedValue = example.metadata.first.computeConstantValue();
          expect(
            typedReader.parse(typedValue),
            TypeLink('List', 'dart:core', [
              TypeLink('Map', 'dart:core', [
                TypeLink('String', 'dart:core'),
  
negative.code: import '../../src/compile.dart';
  import '../../src/resolve.dart';
  
  // TODO(leonsenft): remove when `Typed` is exported publicly.
  final typedImport =
      angular.replaceFirst('angular.dart', 'src/core/metadata/typed.dart');
  
  Future<TypeLink> parse(String source) async {
    final amendedSource = 'import "$typedImport";\n$source';
    final element = await resolveClass(amendedSource);
    final typedReader = TypedReader(element);
    final typedValue = element.metadata.first.computeConstantValue();
    return typedReader.parse(typedValue);
  }
  
  void main() {
    group('parses', () {
      group('Typed()', () {
        test('with single concrete type argument', () async {
          final typeLink = await parse('''
            const typed = Typed<List<String>>();
  
            @typed
            class Example {}
          ''');
          expect(
            typeLink,
            TypeLink('List', 'dart:core', [
              TypeLink('String', 'dart:core'),
            ]),
          );
        });
        test('with multiple concrete type arguments', () async {
          final typeLink = await parse('''
            const typed = Typed<Map<String, Object>>();
  
            @typed
            class Example {}
          ''');
          expect(
            typeLink,
            TypeLink('Map', 'dart:core', [
              TypeLink('String', 'dart:core'),
              TypeLink('Object', 'dart:core'),
  