API clean-up

pkg/analyzer/test/generated/ast_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.ast_test;
 
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 2093 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")));
     _assertSource("@deprecated class C {}", declaration);
   }
 
   void test_visitClassTypeAlias_abstract() {
     _assertSource(
         "abstract class C = S with M1;",
         AstFactory.classTypeAlias(
             "C",
             null,
             Keyword.ABSTRACT,
@@ skipping 88 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")));
     _assertSource("@deprecated class C = S with M1;", declaration);
   }
 
   void test_visitComment() {
     _assertSource(
         "",
         Comment.createBlockComment(
             <Token>[TokenFactory.tokenFromString("/* comment */")]));
   }
 
@@ skipping 180 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")));
     _assertSource("@deprecated C() {}", declaration);
   }
 
   void test_visitConstructorFieldInitializer_withoutThis() {
     _assertSource(
         "a = b",
         AstFactory.constructorFieldInitializer(
             false,
             "a",
             AstFactory.identifier3("b")));
@@ skipping 108 matching lines @@
                 AstFactory.showCombinator([AstFactory.identifier3("A")]),
                 AstFactory.hideCombinator([AstFactory.identifier3("B")])]));
   }
 
   void test_visitExportDirective_minimal() {
     _assertSource("export 'a.dart';", 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")));
     _assertSource("@deprecated export 'a.dart';", directive);
   }
 
   void test_visitExpressionFunctionBody_async() {
     _assertSource(
         "async => a;",
         AstFactory.asyncExpressionFunctionBody(AstFactory.identifier3("a")));
   }
 
   void test_visitExpressionFunctionBody_simple() {
@@ skipping 30 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")));
     _assertSource("@deprecated var a;", declaration);
   }
 
   void test_visitFieldFormalParameter_functionTyped() {
     _assertSource(
         "A this.a(b)",
         AstFactory.fieldFormalParameter(
             null,
             AstFactory.typeName4("A"),
             "a",
@@ skipping 413 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")));
     _assertSource("@deprecated f() {}", declaration);
   }
 
   void test_visitFunctionDeclarationStatement() {
     _assertSource(
         "f() {}",
         AstFactory.functionDeclarationStatement(
             null,
             null,
             "f",
@@ skipping 29 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")));
     _assertSource("@deprecated typedef A F();", declaration);
   }
 
   void test_visitFunctionTypedFormalParameter_noType() {
     _assertSource("f()", AstFactory.functionTypedFormalParameter(null, "f"));
   }
 
   void test_visitFunctionTypedFormalParameter_type() {
     _assertSource(
         "T f()",
@@ skipping 81 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")));
     _assertSource("@deprecated import 'a.dart';", directive);
   }
 
   void test_visitImportHideCombinator_multiple() {
     _assertSource(
         "hide a, b",
         AstFactory.hideCombinator(
             [AstFactory.identifier3("a"), AstFactory.identifier3("b")]));
   }
 
@@ skipping 102 matching lines @@
             [AstFactory.label2("a")],
             AstFactory.returnStatement()));
   }
 
   void test_visitLibraryDirective() {
     _assertSource("library l;", 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")));
     _assertSource("@deprecated library l;", directive);
   }
 
   void test_visitLibraryIdentifier_multiple() {
     _assertSource(
         "a.b.c",
         AstFactory.libraryIdentifier(
             [
                 AstFactory.identifier3("a"),
                 AstFactory.identifier3("b"),
@@ skipping 222 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")));
     _assertSource("@deprecated m() {}", declaration);
   }
 
   void test_visitMethodInvocation_noTarget() {
     _assertSource("m()", AstFactory.methodInvocation2("m"));
   }
 
   void test_visitMethodInvocation_target() {
     _assertSource(
         "t.m()",
@@ skipping 31 matching lines @@
         "(a)",
         AstFactory.parenthesizedExpression(AstFactory.identifier3("a")));
   }
 
   void test_visitPartDirective() {
     _assertSource("part 'a.dart';", 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")));
     _assertSource("@deprecated part 'a.dart';", directive);
   }
 
   void test_visitPartOfDirective() {
     _assertSource(
         "part of l;",
         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")));
     _assertSource("@deprecated part of l;", directive);
   }
 
   void test_visitPositionalFormalParameter() {
     _assertSource(
         "var a = 0",
         AstFactory.positionalFormalParameter(
             AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
             AstFactory.integer(0)));
   }
@@ skipping 273 matching lines @@
   }
 
   void test_visitTypeParameter_withExtends() {
     _assertSource(
         "E extends C",
         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")));
     _assertSource("@deprecated E", parameter);
   }
 
   void test_visitTypeParameter_withoutExtends() {
     _assertSource("E", AstFactory.typeParameter("E"));
   }
 
   void test_visitTypeParameterList_multiple() {
     _assertSource("<E, F>", AstFactory.typeParameterList(["E", "F"]));
   }
 
   void test_visitTypeParameterList_single() {
     _assertSource("<E>", AstFactory.typeParameterList(["E"]));
   }
 
   void test_visitVariableDeclaration_initialized() {
     _assertSource(
         "a = b",
         AstFactory.variableDeclaration2("a", AstFactory.identifier3("b")));
   }
 
   void test_visitVariableDeclaration_uninitialized() {
     _assertSource("a", 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")));
     _assertSource("@deprecated a", declaration);
   }
 
   void test_visitVariableDeclarationList_const_type() {
     _assertSource(
         "const C a, b",
         AstFactory.variableDeclarationList(
             Keyword.CONST,
             AstFactory.typeName4("C"),
             [AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]));
   }
 
   void test_visitVariableDeclarationList_final_noType() {
     _assertSource(
         "final a, b",
         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")));
     _assertSource("@deprecated final a, b", declarationList);
   }
 
   void test_visitVariableDeclarationList_type() {
     _assertSource(
         "C a, b",
         AstFactory.variableDeclarationList(
             null,
             AstFactory.typeName4("C"),
             [AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]));
@@ skipping 101 matching lines @@
 
   static const List<WrapperKind> values = const [
       PREFIXED_LEFT,
       PREFIXED_RIGHT,
       PROPERTY_LEFT,
       PROPERTY_RIGHT,
       NONE];
 
   const WrapperKind(String name, int ordinal) : super(name, ordinal);
 }