API clean-up

pkg/analyzer/test/generated/utilities_test.dart

 // Copyright (c) 2014, 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.utilities_test;
 
 import 'dart:collection';
@@ skipping 341 matching lines @@
             [
                 AstFactory.fieldDeclaration2(
                     false,
                     Keyword.VAR,
                     [AstFactory.variableDeclaration("a")])]));
   }
 
   void test_visitClassDeclaration_withMetadata() {
     ClassDeclaration declaration =
         AstFactory.classDeclaration(null, "C", null, null, null, null);
-    declaration.metadata =
-        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    declaration.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
     _assertClone(declaration);
   }
 
   void test_visitClassTypeAlias_abstract() {
     _assertClone(
         AstFactory.classTypeAlias(
             "C",
             null,
             Keyword.ABSTRACT,
             AstFactory.typeName4("S"),
@@ skipping 80 matching lines @@
   }
 
   void test_visitClassTypeAlias_withMetadata() {
     ClassTypeAlias declaration = AstFactory.classTypeAlias(
         "C",
         null,
         null,
         AstFactory.typeName4("S"),
         AstFactory.withClause([AstFactory.typeName4("M1")]),
         null);
-    declaration.metadata =
-        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    declaration.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
     _assertClone(declaration);
   }
 
   void test_visitComment() {
     _assertClone(
         Comment.createBlockComment(
             <Token>[TokenFactory.tokenFromString("/* comment */")]));
   }
 
   void test_visitCommentReference() {
@@ skipping 163 matching lines @@
 
   void test_visitConstructorDeclaration_withMetadata() {
     ConstructorDeclaration declaration = AstFactory.constructorDeclaration2(
         null,
         null,
         AstFactory.identifier3("C"),
         null,
         AstFactory.formalParameterList(),
         null,
         AstFactory.blockFunctionBody2());
-    declaration.metadata =
-        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    declaration.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
     _assertClone(declaration);
   }
 
   void test_visitConstructorFieldInitializer_withoutThis() {
     _assertClone(
         AstFactory.constructorFieldInitializer(
             false,
             "a",
             AstFactory.identifier3("b")));
   }
@@ skipping 85 matching lines @@
                 AstFactory.showCombinator([AstFactory.identifier3("A")]),
                 AstFactory.hideCombinator([AstFactory.identifier3("B")])]));
   }
 
   void test_visitExportDirective_minimal() {
     _assertClone(AstFactory.exportDirective2("a.dart"));
   }
 
   void test_visitExportDirective_withMetadata() {
     ExportDirective directive = AstFactory.exportDirective2("a.dart");
-    directive.metadata =
-        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    directive.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
     _assertClone(directive);
   }
 
   void test_visitExpressionFunctionBody() {
     _assertClone(
         AstFactory.expressionFunctionBody(AstFactory.identifier3("a")));
   }
 
   void test_visitExpressionStatement() {
     _assertClone(AstFactory.expressionStatement(AstFactory.identifier3("a")));
@@ skipping 17 matching lines @@
             true,
             Keyword.VAR,
             [AstFactory.variableDeclaration("a")]));
   }
 
   void test_visitFieldDeclaration_withMetadata() {
     FieldDeclaration declaration = AstFactory.fieldDeclaration2(
         false,
         Keyword.VAR,
         [AstFactory.variableDeclaration("a")]);
-    declaration.metadata =
-        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    declaration.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
     _assertClone(declaration);
   }
 
   void test_visitFieldFormalParameter_functionTyped() {
     _assertClone(
         AstFactory.fieldFormalParameter(
             null,
             AstFactory.typeName4("A"),
             "a",
             AstFactory.formalParameterList([AstFactory.simpleFormalParameter3("b")])));
@@ skipping 335 matching lines @@
             "f",
             AstFactory.functionExpression()));
   }
 
   void test_visitFunctionDeclaration_withMetadata() {
     FunctionDeclaration declaration = AstFactory.functionDeclaration(
         null,
         null,
         "f",
         AstFactory.functionExpression());
-    declaration.metadata =
-        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    declaration.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
     _assertClone(declaration);
   }
 
   void test_visitFunctionDeclarationStatement() {
     _assertClone(
         AstFactory.functionDeclarationStatement(
             null,
             null,
             "f",
             AstFactory.functionExpression()));
@@ skipping 25 matching lines @@
             null,
             AstFactory.formalParameterList()));
   }
 
   void test_visitFunctionTypeAlias_withMetadata() {
     FunctionTypeAlias declaration = AstFactory.typeAlias(
         AstFactory.typeName4("A"),
         "F",
         null,
         AstFactory.formalParameterList());
-    declaration.metadata =
-        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    declaration.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
     _assertClone(declaration);
   }
 
   void test_visitFunctionTypedFormalParameter_noType() {
     _assertClone(AstFactory.functionTypedFormalParameter(null, "f"));
   }
 
   void test_visitFunctionTypedFormalParameter_type() {
     _assertClone(
         AstFactory.functionTypedFormalParameter(AstFactory.typeName4("T"), "f"));
@@ skipping 61 matching lines @@
         AstFactory.importDirective3(
             "a.dart",
             "p",
             [
                 AstFactory.showCombinator([AstFactory.identifier3("A")]),
                 AstFactory.hideCombinator([AstFactory.identifier3("B")])]));
   }
 
   void test_visitImportDirective_withMetadata() {
     ImportDirective directive = AstFactory.importDirective3("a.dart", null);
-    directive.metadata =
-        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    directive.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
     _assertClone(directive);
   }
 
   void test_visitImportHideCombinator_multiple() {
     _assertClone(
         AstFactory.hideCombinator(
             [AstFactory.identifier3("a"), AstFactory.identifier3("b")]));
   }
 
   void test_visitImportHideCombinator_single() {
@@ skipping 87 matching lines @@
             [AstFactory.label2("a")],
             AstFactory.returnStatement()));
   }
 
   void test_visitLibraryDirective() {
     _assertClone(AstFactory.libraryDirective2("l"));
   }
 
   void test_visitLibraryDirective_withMetadata() {
     LibraryDirective directive = AstFactory.libraryDirective2("l");
-    directive.metadata =
-        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    directive.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
     _assertClone(directive);
   }
 
   void test_visitLibraryIdentifier_multiple() {
     _assertClone(
         AstFactory.libraryIdentifier(
             [
                 AstFactory.identifier3("a"),
                 AstFactory.identifier3("b"),
                 AstFactory.identifier3("c")]));
@@ skipping 202 matching lines @@
 
   void test_visitMethodDeclaration_withMetadata() {
     MethodDeclaration declaration = AstFactory.methodDeclaration2(
         null,
         null,
         null,
         null,
         AstFactory.identifier3("m"),
         AstFactory.formalParameterList(),
         AstFactory.blockFunctionBody2());
-    declaration.metadata =
-        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    declaration.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
     _assertClone(declaration);
   }
 
   void test_visitMethodInvocation_noTarget() {
     _assertClone(AstFactory.methodInvocation2("m"));
   }
 
   void test_visitMethodInvocation_target() {
     _assertClone(AstFactory.methodInvocation(AstFactory.identifier3("t"), "m"));
   }
@@ skipping 25 matching lines @@
     _assertClone(
         AstFactory.parenthesizedExpression(AstFactory.identifier3("a")));
   }
 
   void test_visitPartDirective() {
     _assertClone(AstFactory.partDirective2("a.dart"));
   }
 
   void test_visitPartDirective_withMetadata() {
     PartDirective directive = AstFactory.partDirective2("a.dart");
-    directive.metadata =
-        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    directive.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
     _assertClone(directive);
   }
 
   void test_visitPartOfDirective() {
     _assertClone(
         AstFactory.partOfDirective(AstFactory.libraryIdentifier2(["l"])));
   }
 
   void test_visitPartOfDirective_withMetadata() {
     PartOfDirective directive =
         AstFactory.partOfDirective(AstFactory.libraryIdentifier2(["l"]));
-    directive.metadata =
-        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    directive.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
     _assertClone(directive);
   }
 
   void test_visitPositionalFormalParameter() {
     _assertClone(
         AstFactory.positionalFormalParameter(
             AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
             AstFactory.integer(0)));
   }
 
@@ skipping 234 matching lines @@
   void test_visitTypeName_singleArg() {
     _assertClone(AstFactory.typeName4("C", [AstFactory.typeName4("D")]));
   }
 
   void test_visitTypeParameter_withExtends() {
     _assertClone(AstFactory.typeParameter2("E", AstFactory.typeName4("C")));
   }
 
   void test_visitTypeParameter_withMetadata() {
     TypeParameter parameter = AstFactory.typeParameter("E");
-    parameter.metadata =
-        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    parameter.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
     _assertClone(parameter);
   }
 
   void test_visitTypeParameter_withoutExtends() {
     _assertClone(AstFactory.typeParameter("E"));
   }
 
   void test_visitTypeParameterList_multiple() {
     _assertClone(AstFactory.typeParameterList(["E", "F"]));
   }
 
   void test_visitTypeParameterList_single() {
     _assertClone(AstFactory.typeParameterList(["E"]));
   }
 
   void test_visitVariableDeclaration_initialized() {
     _assertClone(
         AstFactory.variableDeclaration2("a", AstFactory.identifier3("b")));
   }
 
   void test_visitVariableDeclaration_uninitialized() {
     _assertClone(AstFactory.variableDeclaration("a"));
   }
 
   void test_visitVariableDeclaration_withMetadata() {
     VariableDeclaration declaration = AstFactory.variableDeclaration("a");
-    declaration.metadata =
-        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    declaration.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
     _assertClone(declaration);
   }
 
   void test_visitVariableDeclarationList_const_type() {
     _assertClone(
         AstFactory.variableDeclarationList(
             Keyword.CONST,
             AstFactory.typeName4("C"),
             [AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]));
   }
 
   void test_visitVariableDeclarationList_final_noType() {
     _assertClone(
         AstFactory.variableDeclarationList2(
             Keyword.FINAL,
             [AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]));
   }
 
   void test_visitVariableDeclarationList_final_withMetadata() {
     VariableDeclarationList declarationList =
         AstFactory.variableDeclarationList2(
             Keyword.FINAL,
             [AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]);
-    declarationList.metadata =
-        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    declarationList.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
     _assertClone(declarationList);
   }
 
   void test_visitVariableDeclarationList_type() {
     _assertClone(
         AstFactory.variableDeclarationList(
             null,
             AstFactory.typeName4("C"),
             [AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]));
   }
@@ skipping 1831 matching lines @@
         AstFactory.extendsClause(AstFactory.typeName4("B")),
         AstFactory.withClause([AstFactory.typeName4("C")]),
         AstFactory.implementsClause([AstFactory.typeName4("D")]),
         [
             AstFactory.fieldDeclaration2(
                 false,
                 null,
                 [AstFactory.variableDeclaration("f")])]);
     node.documentationComment =
         Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
-    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
+    node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
     node.nativeClause = AstFactory.nativeClause("");
     _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration_6());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration_5());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration_4());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration_2());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration_3());
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_classDeclaration(0));
     _testAnnotatedNode(node);
   }
 
   void test_classTypeAlias() {
     ClassTypeAlias node = AstFactory.classTypeAlias(
         "A",
         AstFactory.typeParameterList(["E"]),
         null,
         AstFactory.typeName4("B"),
         AstFactory.withClause([AstFactory.typeName4("C")]),
         AstFactory.implementsClause([AstFactory.typeName4("D")]));
     node.documentationComment =
         Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
-    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
+    node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
     _assertReplace(node, new Getter_NodeReplacerTest_test_classTypeAlias_4());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classTypeAlias_5());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classTypeAlias());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classTypeAlias_3());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classTypeAlias_2());
     _testAnnotatedNode(node);
   }
 
   void test_comment() {
     Comment node = Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
@@ skipping 45 matching lines @@
     ConstructorDeclaration node = AstFactory.constructorDeclaration2(
         null,
         null,
         AstFactory.identifier3("C"),
         "d",
         AstFactory.formalParameterList(),
         [AstFactory.constructorFieldInitializer(false, "x", AstFactory.integer(0))],
         AstFactory.emptyFunctionBody());
     node.documentationComment =
         Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
-    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
+    node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
     node.redirectedConstructor =
         AstFactory.constructorName(AstFactory.typeName4("B"), "a");
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_constructorDeclaration_3());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_constructorDeclaration_2());
     _assertReplace(
         node,
@@ skipping 31 matching lines @@
   void test_continueStatement() {
     ContinueStatement node = AstFactory.continueStatement("l");
     _assertReplace(node, new Getter_NodeReplacerTest_test_continueStatement());
   }
 
   void test_declaredIdentifier() {
     DeclaredIdentifier node =
         AstFactory.declaredIdentifier4(AstFactory.typeName4("C"), "i");
     node.documentationComment =
         Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
-    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
+    node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
     _assertReplace(node, new Getter_NodeReplacerTest_test_declaredIdentifier());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_declaredIdentifier_2());
     _testAnnotatedNode(node);
   }
 
   void test_defaultFormalParameter() {
     DefaultFormalParameter node = AstFactory.positionalFormalParameter(
         AstFactory.simpleFormalParameter3("p"),
@@ skipping 21 matching lines @@
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_enumConstantDeclaration());
     _testAnnotatedNode(node);
   }
 
   void test_enumDeclaration() {
     EnumDeclaration node = AstFactory.enumDeclaration2("E", ["ONE", "TWO"]);
     node.documentationComment =
         Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
-    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
+    node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
     _assertReplace(node, new Getter_NodeReplacerTest_test_enumDeclaration());
     _testAnnotatedNode(node);
   }
 
   void test_exportDirective() {
     ExportDirective node =
         AstFactory.exportDirective2("", [AstFactory.hideCombinator2(["C"])]);
     node.documentationComment =
         Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
-    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
+    node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
     _testNamespaceDirective(node);
   }
 
   void test_expressionFunctionBody() {
     ExpressionFunctionBody node =
         AstFactory.expressionFunctionBody(AstFactory.integer(0));
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_expressionFunctionBody());
   }
@@ skipping 12 matching lines @@
   }
 
   void test_fieldDeclaration() {
     FieldDeclaration node = AstFactory.fieldDeclaration(
         false,
         null,
         AstFactory.typeName4("C"),
         [AstFactory.variableDeclaration("c")]);
     node.documentationComment =
         Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
-    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
+    node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
     _assertReplace(node, new Getter_NodeReplacerTest_test_fieldDeclaration());
     _testAnnotatedNode(node);
   }
 
   void test_fieldFormalParameter() {
     FieldFormalParameter node = AstFactory.fieldFormalParameter(
         null,
         AstFactory.typeName4("C"),
         "f",
         AstFactory.formalParameterList());
@@ skipping 94 matching lines @@
   void test_functionDeclaration() {
     FunctionDeclaration node = AstFactory.functionDeclaration(
         AstFactory.typeName4("R"),
         null,
         "f",
         AstFactory.functionExpression2(
             AstFactory.formalParameterList(),
             AstFactory.blockFunctionBody(AstFactory.block())));
     node.documentationComment =
         Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
-    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
+    node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_functionDeclaration());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_functionDeclaration_3());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_functionDeclaration_2());
     _testAnnotatedNode(node);
@@ skipping 35 matching lines @@
   }
 
   void test_functionTypeAlias() {
     FunctionTypeAlias node = AstFactory.typeAlias(
         AstFactory.typeName4("R"),
         "F",
         AstFactory.typeParameterList(["E"]),
         AstFactory.formalParameterList());
     node.documentationComment =
         Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
-    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
+    node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_functionTypeAlias_3());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_functionTypeAlias_4());
     _assertReplace(node, new Getter_NodeReplacerTest_test_functionTypeAlias());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_functionTypeAlias_2());
@@ skipping 42 matching lines @@
         new ListGetter_NodeReplacerTest_test_implementsClause(0));
   }
 
   void test_importDirective() {
     ImportDirective node = AstFactory.importDirective3(
         "",
         "p",
         [AstFactory.showCombinator2(["A"]), AstFactory.hideCombinator2(["B"])]);
     node.documentationComment =
         Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
-    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
+    node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
     _assertReplace(node, new Getter_NodeReplacerTest_test_importDirective());
     _testNamespaceDirective(node);
   }
 
   void test_indexExpression() {
     IndexExpression node = AstFactory.indexExpression(
         AstFactory.identifier3("a"),
         AstFactory.identifier3("i"));
     _assertReplace(node, new Getter_NodeReplacerTest_test_indexExpression());
     _assertReplace(node, new Getter_NodeReplacerTest_test_indexExpression_2());
@@ skipping 40 matching lines @@
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_labeledStatement(0));
     _assertReplace(node, new Getter_NodeReplacerTest_test_labeledStatement());
   }
 
   void test_libraryDirective() {
     LibraryDirective node = AstFactory.libraryDirective2("lib");
     node.documentationComment =
         Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
-    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
+    node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
     _assertReplace(node, new Getter_NodeReplacerTest_test_libraryDirective());
     _testAnnotatedNode(node);
   }
 
   void test_libraryIdentifier() {
     LibraryIdentifier node = AstFactory.libraryIdentifier2(["lib"]);
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_libraryIdentifier(0));
   }
@@ skipping 27 matching lines @@
     MethodDeclaration node = AstFactory.methodDeclaration2(
         null,
         AstFactory.typeName4("A"),
         null,
         null,
         AstFactory.identifier3("m"),
         AstFactory.formalParameterList(),
         AstFactory.blockFunctionBody(AstFactory.block()));
     node.documentationComment =
         Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
-    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
+    node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
     _assertReplace(node, new Getter_NodeReplacerTest_test_methodDeclaration());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_methodDeclaration_3());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_methodDeclaration_4());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_methodDeclaration_2());
@@ skipping 32 matching lines @@
         AstFactory.parenthesizedExpression(AstFactory.integer(0));
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_parenthesizedExpression());
   }
 
   void test_partDirective() {
     PartDirective node = AstFactory.partDirective2("");
     node.documentationComment =
         Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
-    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
+    node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
     _testUriBasedDirective(node);
   }
 
   void test_partOfDirective() {
     PartOfDirective node =
         AstFactory.partOfDirective(AstFactory.libraryIdentifier2(["lib"]));
     node.documentationComment =
         Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
-    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
+    node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
     _assertReplace(node, new Getter_NodeReplacerTest_test_partOfDirective());
     _testAnnotatedNode(node);
   }
 
   void test_postfixExpression() {
     PostfixExpression node = AstFactory.postfixExpression(
         AstFactory.identifier3("x"),
         TokenType.MINUS_MINUS);
     _assertReplace(node, new Getter_NodeReplacerTest_test_postfixExpression());
   }
@@ skipping 109 matching lines @@
     _assertReplace(node, new Getter_NodeReplacerTest_test_throwExpression());
   }
 
   void test_topLevelVariableDeclaration() {
     TopLevelVariableDeclaration node = AstFactory.topLevelVariableDeclaration(
         null,
         AstFactory.typeName4("T"),
         [AstFactory.variableDeclaration("t")]);
     node.documentationComment =
         Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
-    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
+    node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_topLevelVariableDeclaration());
     _testAnnotatedNode(node);
   }
 
   void test_tryStatement() {
     TryStatement node = AstFactory.tryStatement3(
         AstFactory.block(),
         [AstFactory.catchClause("e", [AstFactory.block()])],
@@ skipping 31 matching lines @@
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_typeParameterList(0));
   }
 
   void test_variableDeclaration() {
     VariableDeclaration node =
         AstFactory.variableDeclaration2("a", AstFactory.nullLiteral());
     node.documentationComment =
         Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
-    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
+    node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_variableDeclaration());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_variableDeclaration_2());
     _testAnnotatedNode(node);
   }
 
   void test_variableDeclarationList() {
@@ skipping 579 matching lines @@
   }
 
   void test_get_added() {
     TokenMap tokenMap = new TokenMap();
     Token key = TokenFactory.tokenFromType(TokenType.AT);
     Token value = TokenFactory.tokenFromType(TokenType.AT);
     tokenMap.put(key, value);
     expect(tokenMap.get(key), same(value));
   }
 }