Support metadata on patches.

tests/compiler/dart2js/metadata_test.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:async_helper/async_helper.dart';
 import 'package:compiler/src/constants/values.dart'
     show PrimitiveConstantValue;
 import 'package:expect/expect.dart';
 import 'compiler_helper.dart';
 import 'package:compiler/src/parser/partial_elements.dart' show
@@ skipping 15 matching lines @@
                      {bool isTopLevelOnly: false}) {
   // Ensure that a compile-time constant can be resolved from an
   // annotation.
   var source1 = """const native = 'xyz';
                    @native
                    $declaration
                    main() {}""";
 
   compileAndCheck(source1, name, (compiler, element) {
     compiler.enqueuer.resolution.queueIsClosed = false;
-    Expect.equals(1, length(element.metadata),
+    Expect.equals(1, element.metadata.length,
         'Unexpected metadata count on $element.');
-    PartialMetadataAnnotation annotation = element.metadata.head;
+    PartialMetadataAnnotation annotation = element.metadata.first;
     annotation.ensureResolved(compiler);
     PrimitiveConstantValue value =
         compiler.constants.getConstantValue(annotation.constant);
     Expect.stringEquals('xyz', value.primitiveValue.slowToString());
 
     checkPosition(annotation, annotation.cachedNode, source1, compiler);
   });
 
   // Ensure that each repeated annotation has a unique instance of
   // [MetadataAnnotation].
   var source2 = """const native = 'xyz';
                    @native @native
                    $declaration
                    main() {}""";
 
   compileAndCheck(source2, name, (compiler, element) {
     compiler.enqueuer.resolution.queueIsClosed = false;
-    Expect.equals(2, length(element.metadata));
-    PartialMetadataAnnotation annotation1 = element.metadata.head;
-    PartialMetadataAnnotation annotation2 = element.metadata.tail.head;
+    Expect.equals(2, element.metadata.length);
+    PartialMetadataAnnotation annotation1 = element.metadata.elementAt(0);
+    PartialMetadataAnnotation annotation2 = element.metadata.elementAt(1);
     annotation1.ensureResolved(compiler);
     annotation2.ensureResolved(compiler);
     Expect.isFalse(identical(annotation1, annotation2),
                    'expected unique instances');
     Expect.notEquals(annotation1, annotation2, 'expected unequal instances');
     PrimitiveConstantValue value1 =
         compiler.constants.getConstantValue(annotation1.constant);
     PrimitiveConstantValue value2 =
         compiler.constants.getConstantValue(annotation2.constant);
     Expect.identical(value1, value2, 'expected same compile-time constant');
@@ skipping 10 matching lines @@
   // annotation.
   var source3 = """const native = 'xyz';
                    class Foo {
                      @native
                      $declaration
                    }
                    main() {}""";
 
   compileAndCheck(source3, 'Foo', (compiler, element) {
     compiler.enqueuer.resolution.queueIsClosed = false;
-    Expect.equals(0, length(element.metadata));
+    Expect.equals(0, element.metadata.length);
     element.ensureResolved(compiler);
-    Expect.equals(0, length(element.metadata));
+    Expect.equals(0, element.metadata.length);
     element = element.lookupLocalMember(name);
-    Expect.equals(1, length(element.metadata));
-    PartialMetadataAnnotation annotation = element.metadata.head;
+    Expect.equals(1, element.metadata.length);
+    PartialMetadataAnnotation annotation = element.metadata.first;
     annotation.ensureResolved(compiler);
     PrimitiveConstantValue value =
         compiler.constants.getConstantValue(annotation.constant);
     Expect.stringEquals('xyz', value.primitiveValue.slowToString());
 
     checkPosition(annotation, annotation.cachedNode, source3, compiler);
   });
 
   // Ensure that each repeated annotation has a unique instance of
   // [MetadataAnnotation].
   var source4 = """const native = 'xyz';
                    class Foo {
                      @native @native
                      $declaration
                    }
                    main() {}""";
 
   compileAndCheck(source4, 'Foo', (compiler, element) {
     compiler.enqueuer.resolution.queueIsClosed = false;
-    Expect.equals(0, length(element.metadata));
+    Expect.equals(0, element.metadata.length);
     element.ensureResolved(compiler);
-    Expect.equals(0, length(element.metadata));
+    Expect.equals(0, element.metadata.length);
     element = element.lookupLocalMember(name);
-    Expect.equals(2, length(element.metadata));
-    PartialMetadataAnnotation annotation1 = element.metadata.head;
-    PartialMetadataAnnotation annotation2 = element.metadata.tail.head;
+    Expect.equals(2, element.metadata.length);
+    PartialMetadataAnnotation annotation1 = element.metadata.elementAt(0);
+    PartialMetadataAnnotation annotation2 = element.metadata.elementAt(1);
     annotation1.ensureResolved(compiler);
     annotation2.ensureResolved(compiler);
     Expect.isFalse(identical(annotation1, annotation2),
                    'expected unique instances');
     Expect.notEquals(annotation1, annotation2, 'expected unequal instances');
     PrimitiveConstantValue value1 =
         compiler.constants.getConstantValue(annotation1.constant);
     PrimitiveConstantValue value2 =
         compiler.constants.getConstantValue(annotation2.constant);
     Expect.identical(value1, value2, 'expected same compile-time constant');
@@ skipping 14 matching lines @@
 }
 
 void testTopLevelFieldMetadata() {
   checkAnnotation('foo', 'var foo;');
   checkAnnotation('bar', 'var foo, bar;');
 }
 
 void testLibraryTags() {
   void compileAndCheckLibrary(
       String source,
-      Link<MetadataAnnotation> extractMetadata(LibraryElement element)) {
+      List<MetadataAnnotation> extractMetadata(LibraryElement element)) {
     Uri partUri = new Uri(scheme: 'source', path: 'part.dart');
     String partSource = '@native part of foo;';
 
     Uri libUri = new Uri(scheme: 'source', path: 'lib.dart');
     String libSource = 'library lib;';
 
     Uri uri = new Uri(scheme: 'source', path: 'main.dart');
 
     var compiler = compilerFor(source, uri)
         ..registerSource(partUri, partSource)
         ..registerSource(libUri, libSource);
 
     asyncTest(() => compiler.runCompiler(uri).then((_) {
       compiler.enqueuer.resolution.queueIsClosed = false;
       LibraryElement element = compiler.libraryLoader.lookupLibrary(uri);
       Expect.isNotNull(element, 'Cannot find $uri');
 
-      Link<MetadataAnnotation> metadata = extractMetadata(element);
-      Expect.equals(1, length(metadata));
+      List<MetadataAnnotation> metadata = extractMetadata(element);
+      Expect.equals(1, metadata.length);
 
-      PartialMetadataAnnotation annotation = metadata.head;
+      PartialMetadataAnnotation annotation = metadata.first;
       annotation.ensureResolved(compiler);
       PrimitiveConstantValue value =
           compiler.constants.getConstantValue(annotation.constant);
       Expect.stringEquals('xyz', value.primitiveValue.slowToString());
 
       checkPosition(annotation, annotation.cachedNode, source, compiler);
     }));
   }
 
   var source;
@@ skipping 29 matching lines @@
   compileAndCheckLibrary(source,
                          (e) => e.compilationUnits.first.partTag.metadata);
 }
 
 void main() {
   testClassMetadata();
   testTopLevelMethodMetadata();
   testTopLevelFieldMetadata();
   testLibraryTags();
 }