Eliminate commentAndMetadata() from parser tests.

pkg/analyzer/test/generated/parser_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.
 
 library analyzer.test.generated.parser_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
@@ skipping 2979 matching lines @@
   GatheringErrorListener listener;
 
   /**
    * The parser used by the test.
    *
    * This field is typically initialized by invoking [createParser].
    */
   Parser parser;
 
   /**
-   * Return a CommentAndMetadata object with the given values that can be used for testing.
-   *
-   * @param comment the comment to be wrapped in the object
-   * @param annotations the annotations to be wrapped in the object
-   * @return a CommentAndMetadata object that can be used for testing
-   */
-  CommentAndMetadata commentAndMetadata(Comment comment,
-      [List<Annotation> annotations]) {
-    return new CommentAndMetadata(comment, annotations);
-  }
-
-  /**
    * Create the [parser] and [listener] used by a test. The [parser] will be
    * prepared to parse the tokens scanned from the given [content].
    */
   void createParser(String content) {
     listener = new GatheringErrorListener();
     //
     // Scan the source.
     //
     TestSource source = new TestSource();
     CharacterReader reader = new CharSequenceReader(content);
@@ skipping 6912 matching lines @@
   void test_parseFunctionBody_skip_expression() {
     ParserTestCase.parseFunctionBodies = false;
     createParser('=> y;');
     FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
     expectNotNullIfNoErrors(functionBody);
     listener.assertNoErrors();
     expect(functionBody, new isInstanceOf<EmptyFunctionBody>());
   }
 
   void test_parseFunctionDeclaration_function() {
-    Comment comment = astFactory.documentationComment(new List<Token>(0));
-    TypeName returnType =
-        astFactory.typeName(astFactory.simpleIdentifier(null), null);
-    createParser('f() {}');
-    FunctionDeclaration declaration = parser.parseFunctionDeclaration(
-        commentAndMetadata(comment), null, returnType);
+    createParser('/// Doc\nT f() {}');
+    FunctionDeclaration declaration = parseFullCompilationUnitMember();
     expectNotNullIfNoErrors(declaration);
     listener.assertNoErrors();
-    expect(declaration.documentationComment, comment);
-    expect(declaration.returnType, returnType);
+    _expectCommentText(declaration.documentationComment, '/// Doc');
+    expect((declaration.returnType as TypeName).name.name, 'T');
     expect(declaration.name, isNotNull);
     FunctionExpression expression = declaration.functionExpression;
     expect(expression, isNotNull);
     expect(expression.body, isNotNull);
     expect(expression.typeParameters, isNull);
     expect(expression.parameters, isNotNull);
     expect(declaration.propertyKeyword, isNull);
   }
 
   void test_parseFunctionDeclaration_functionWithTypeParameters() {
-    Comment comment = astFactory.documentationComment(new List<Token>(0));
-    TypeName returnType =
-        astFactory.typeName(astFactory.simpleIdentifier(null), null);
-    createParser('f<E>() {}');
-    FunctionDeclaration declaration = parser.parseFunctionDeclaration(
-        commentAndMetadata(comment), null, returnType);
+    createParser('/// Doc\nT f<E>() {}');
+    FunctionDeclaration declaration = parseFullCompilationUnitMember();
     expectNotNullIfNoErrors(declaration);
     listener.assertNoErrors();
-    expect(declaration.documentationComment, comment);
-    expect(declaration.returnType, returnType);
+    _expectCommentText(declaration.documentationComment, '/// Doc');
+    expect((declaration.returnType as TypeName).name.name, 'T');
     expect(declaration.name, isNotNull);
     FunctionExpression expression = declaration.functionExpression;
     expect(expression, isNotNull);
     expect(expression.body, isNotNull);
     expect(expression.typeParameters, isNotNull);
     expect(expression.parameters, isNotNull);
     expect(declaration.propertyKeyword, isNull);
   }
 
   void test_parseFunctionDeclaration_functionWithTypeParameters_comment() {
     enableGenericMethodComments = true;
-    Comment comment = astFactory.documentationComment(new List<Token>(0));
-    TypeName returnType =
-        astFactory.typeName(astFactory.simpleIdentifier(null), null);
-    createParser('f/*<E>*/() {}');
-    FunctionDeclaration declaration = parser.parseFunctionDeclaration(
-        commentAndMetadata(comment), null, returnType);
+    createParser('/// Doc\nT f/*<E>*/() {}');
+    FunctionDeclaration declaration = parseFullCompilationUnitMember();
     expectNotNullIfNoErrors(declaration);
     listener.assertNoErrors();
-    expect(declaration.documentationComment, comment);
-    expect(declaration.returnType, returnType);
+    _expectCommentText(declaration.documentationComment, '/// Doc');
+    expect((declaration.returnType as TypeName).name.name, 'T');
     expect(declaration.name, isNotNull);
     FunctionExpression expression = declaration.functionExpression;
     expect(expression, isNotNull);
     expect(expression.body, isNotNull);
     expect(expression.typeParameters, isNotNull);
     expect(expression.parameters, isNotNull);
     expect(declaration.propertyKeyword, isNull);
   }
 
   void test_parseFunctionDeclaration_getter() {
-    Comment comment = astFactory.documentationComment(new List<Token>(0));
-    TypeName returnType =
-        astFactory.typeName(astFactory.simpleIdentifier(null), null);
-    createParser('get p => 0;');
-    FunctionDeclaration declaration = parser.parseFunctionDeclaration(
-        commentAndMetadata(comment), null, returnType);
+    createParser('/// Doc\nT get p => 0;');
+    FunctionDeclaration declaration = parseFullCompilationUnitMember();
     expectNotNullIfNoErrors(declaration);
     listener.assertNoErrors();
-    expect(declaration.documentationComment, comment);
-    expect(declaration.returnType, returnType);
+    _expectCommentText(declaration.documentationComment, '/// Doc');
+    expect((declaration.returnType as TypeName).name.name, 'T');
     expect(declaration.name, isNotNull);
     FunctionExpression expression = declaration.functionExpression;
     expect(expression, isNotNull);
     expect(expression.body, isNotNull);
     expect(expression.typeParameters, isNull);
     expect(expression.parameters, isNull);
     expect(declaration.propertyKeyword, isNotNull);
   }
 
   void test_parseFunctionDeclaration_setter() {
-    Comment comment = astFactory.documentationComment(new List<Token>(0));
-    TypeName returnType =
-        astFactory.typeName(astFactory.simpleIdentifier(null), null);
-    createParser('set p(v) {}');
-    FunctionDeclaration declaration = parser.parseFunctionDeclaration(
-        commentAndMetadata(comment), null, returnType);
+    createParser('/// Doc\nT set p(v) {}');
+    FunctionDeclaration declaration = parseFullCompilationUnitMember();
     expectNotNullIfNoErrors(declaration);
     listener.assertNoErrors();
-    expect(declaration.documentationComment, comment);
-    expect(declaration.returnType, returnType);
+    _expectCommentText(declaration.documentationComment, '/// Doc');
+    expect((declaration.returnType as TypeName).name.name, 'T');
     expect(declaration.name, isNotNull);
     FunctionExpression expression = declaration.functionExpression;
     expect(expression, isNotNull);
     expect(expression.body, isNotNull);
     expect(expression.typeParameters, isNull);
     expect(expression.parameters, isNotNull);
     expect(declaration.propertyKeyword, isNotNull);
   }
 
   void test_parseFunctionDeclarationStatement() {
@@ skipping 100 matching lines @@
     listener.assertNoErrors();
     expect(alias.name, isNotNull);
     expect(alias.name.name, 'F');
     expect(alias.typeParameters, isNotNull);
     expect(alias.equals, isNotNull);
     expect(alias.functionType, isNotNull);
     expect(alias.semicolon, isNotNull);
   }
 
   void test_parseGetter_nonStatic() {
-    Comment comment = astFactory.documentationComment(new List<Token>(0));
-    TypeName returnType =
-        astFactory.typeName(astFactory.simpleIdentifier(null), null);
-    createParser('get a;');
-    MethodDeclaration method =
-        parser.parseGetter(commentAndMetadata(comment), null, null, returnType);
+    createParser('/// Doc\nT get a;');
+    MethodDeclaration method = parser.parseClassMember('C');
     expectNotNullIfNoErrors(method);
     listener.assertNoErrors();
     expect(method.body, isNotNull);
-    expect(method.documentationComment, comment);
+    _expectCommentText(method.documentationComment, '/// Doc');
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
     expect(method.parameters, isNull);
     expect(method.propertyKeyword, isNotNull);
-    expect(method.returnType, returnType);
+    expect((method.returnType as TypeName).name.name, 'T');
   }
 
   void test_parseGetter_static() {
-    Comment comment = astFactory.documentationComment(new List<Token>(0));
-    Token staticKeyword = TokenFactory.tokenFromKeyword(Keyword.STATIC);
-    TypeName returnType =
-        astFactory.typeName(astFactory.simpleIdentifier(null), null);
-    createParser('get a => 42;');
-    MethodDeclaration method = parser.parseGetter(
-        commentAndMetadata(comment), null, staticKeyword, returnType);
+    createParser('/// Doc\nstatic T get a => 42;');
+    MethodDeclaration method = parser.parseClassMember('C');
     expectNotNullIfNoErrors(method);
     listener.assertNoErrors();
     expect(method.body, isNotNull);
-    expect(method.documentationComment, comment);
+    _expectCommentText(method.documentationComment, '/// Doc');
     expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, staticKeyword);
+    expect(method.modifierKeyword.lexeme, 'static');
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
     expect(method.typeParameters, isNull);
     expect(method.parameters, isNull);
     expect(method.propertyKeyword, isNotNull);
-    expect(method.returnType, returnType);
+    expect((method.returnType as TypeName).name.name, 'T');
   }
 
   void test_parseIdentifierList_multiple() {
     createParser('a, b, c');
     List<SimpleIdentifier> list = parser.parseIdentifierList();
     expectNotNullIfNoErrors(list);
     listener.assertNoErrors();
     expect(list, hasLength(3));
   }
 
@@ skipping 204 matching lines @@
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.deferredKeyword, isNull);
     expect(directive.asKeyword, isNull);
     expect(directive.prefix, isNull);
     expect(directive.combinators, hasLength(1));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseInitializedIdentifierList_type() {
-    Comment comment = astFactory.documentationComment(new List<Token>(0));
-    Token staticKeyword = TokenFactory.tokenFromKeyword(Keyword.STATIC);
-    TypeName type =
-        astFactory.typeName(astFactory.simpleIdentifier(null), null);
-    createParser("a = 1, b, c = 3;");
-    FieldDeclaration declaration = parser.parseInitializedIdentifierList(
-        commentAndMetadata(comment), staticKeyword, null, null, type);
+    createParser("/// Doc\nstatic T a = 1, b, c = 3;");
+    FieldDeclaration declaration = parser.parseClassMember('C');
     expectNotNullIfNoErrors(declaration);
     listener.assertNoErrors();
-    expect(declaration.documentationComment, comment);
+    _expectCommentText(declaration.documentationComment, '/// Doc');
     VariableDeclarationList fields = declaration.fields;
     expect(fields, isNotNull);
     expect(fields.keyword, isNull);
-    expect(fields.type, type);
+    expect((fields.type as TypeName).name.name, 'T');
     expect(fields.variables, hasLength(3));
-    expect(declaration.staticKeyword, staticKeyword);
+    expect(declaration.staticKeyword.lexeme, 'static');
     expect(declaration.semicolon, isNotNull);
   }
 
   void test_parseInitializedIdentifierList_var() {
-    Comment comment = astFactory.documentationComment(new List<Token>(0));
-    Token staticKeyword = TokenFactory.tokenFromKeyword(Keyword.STATIC);
-    Token varKeyword = TokenFactory.tokenFromKeyword(Keyword.VAR);
-    createParser('a = 1, b, c = 3;');
-    FieldDeclaration declaration = parser.parseInitializedIdentifierList(
-        commentAndMetadata(comment), staticKeyword, null, varKeyword, null);
+    createParser('/// Doc\nstatic var a = 1, b, c = 3;');
+    FieldDeclaration declaration = parser.parseClassMember('C');
     expectNotNullIfNoErrors(declaration);
     listener.assertNoErrors();
-    expect(declaration.documentationComment, comment);
+    _expectCommentText(declaration.documentationComment, '/// Doc');
     VariableDeclarationList fields = declaration.fields;
     expect(fields, isNotNull);
-    expect(fields.keyword, varKeyword);
+    expect(fields.keyword.lexeme, 'var');
     expect(fields.type, isNull);
     expect(fields.variables, hasLength(3));
-    expect(declaration.staticKeyword, staticKeyword);
+    expect(declaration.staticKeyword.lexeme, 'static');
     expect(declaration.semicolon, isNotNull);
   }
 
   void test_parseInstanceCreationExpression_qualifiedType() {
     Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
     createParser('A.B()');
     InstanceCreationExpression expression =
         parser.parseInstanceCreationExpression(token);
     expectNotNullIfNoErrors(expression);
     listener.assertNoErrors();
@@ skipping 1190 matching lines @@
     expectNotNullIfNoErrors(parameter);
     listener.assertNoErrors();
     expect(parameter, new isInstanceOf<SimpleFormalParameter>());
     SimpleFormalParameter simpleParameter = parameter;
     expect(simpleParameter.keyword, isNull);
     expect(simpleParameter.type, isNotNull);
     expect(simpleParameter.identifier, isNotNull);
   }
 
   void test_parseOperator() {
-    Comment comment = astFactory.documentationComment(new List<Token>(0));
-    TypeName returnType =
-        astFactory.typeName(astFactory.simpleIdentifier(null), null);
-    createParser('operator +(A a);');
-    MethodDeclaration method =
-        parser.parseOperator(commentAndMetadata(comment), null, returnType);
+    createParser('/// Doc\nT operator +(A a);');
+    MethodDeclaration method = parser.parseClassMember('C');
     expectNotNullIfNoErrors(method);
     listener.assertNoErrors();
     expect(method.body, isNotNull);
-    expect(method.documentationComment, comment);
+    _expectCommentText(method.documentationComment, '/// Doc');
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNotNull);
     expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.propertyKeyword, isNull);
-    expect(method.returnType, returnType);
+    expect((method.returnType as TypeName).name.name, 'T');
   }
 
   void test_parseOptionalReturnType() {
     // TODO(brianwilkerson) Implement tests for this method.
   }
 
   void test_parsePartDirective() {
     createParser("part 'lib/lib.dart';");
     PartDirective directive = parseFullDirective();
     expectNotNullIfNoErrors(directive);
@@ skipping 679 matching lines @@
   void test_parseReturnType_void() {
     createParser('void');
     TypeName typeName = parser.parseReturnType(false);
     expectNotNullIfNoErrors(typeName);
     listener.assertNoErrors();
     expect(typeName.name, isNotNull);
     expect(typeName.typeArguments, isNull);
   }
 
   void test_parseSetter_nonStatic() {
-    Comment comment = astFactory.documentationComment(new List<Token>(0));
-    TypeName returnType =
-        astFactory.typeName(astFactory.simpleIdentifier(null), null);
-    createParser('set a(var x);');
-    MethodDeclaration method =
-        parser.parseSetter(commentAndMetadata(comment), null, null, returnType);
+    createParser('/// Doc\nT set a(var x);');
+    MethodDeclaration method = parser.parseClassMember('C');
     expectNotNullIfNoErrors(method);
     listener.assertNoErrors();
     expect(method.body, isNotNull);
-    expect(method.documentationComment, comment);
+    _expectCommentText(method.documentationComment, '/// Doc');
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
     expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.propertyKeyword, isNotNull);
-    expect(method.returnType, returnType);
+    expect((method.returnType as TypeName).name.name, 'T');
   }
 
   void test_parseSetter_static() {
-    Comment comment = astFactory.documentationComment(new List<Token>(0));
-    Token staticKeyword = TokenFactory.tokenFromKeyword(Keyword.STATIC);
-    TypeName returnType =
-        astFactory.typeName(astFactory.simpleIdentifier(null), null);
-    createParser('set a(var x) {}');
-    MethodDeclaration method = parser.parseSetter(
-        commentAndMetadata(comment), null, staticKeyword, returnType);
+    createParser('/// Doc\nstatic T set a(var x) {}');
+    MethodDeclaration method = parser.parseClassMember('C');
     expectNotNullIfNoErrors(method);
     listener.assertNoErrors();
     expect(method.body, isNotNull);
-    expect(method.documentationComment, comment);
+    _expectCommentText(method.documentationComment, '/// Doc');
     expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, staticKeyword);
+    expect(method.modifierKeyword.lexeme, 'static');
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
     expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.propertyKeyword, isNotNull);
-    expect(method.returnType, returnType);
+    expect((method.returnType as TypeName).name.name, 'T');
   }
 
   void test_parseShiftExpression_normal() {
     createParser('x << y');
     BinaryExpression expression = parser.parseShiftExpression();
     expectNotNullIfNoErrors(expression);
     listener.assertNoErrors();
     expect(expression.leftOperand, isNotNull);
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.LT_LT);
@@ skipping 1989 matching lines @@
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    */
   String _computeStringValue(String lexeme, bool first, bool last) {
     createParser('');
     String value = parser.computeStringValue(lexeme, first, last);
     listener.assertNoErrors();
     return value;
   }
 
+  void _expectCommentText(Comment comment, String expectedText) {
+    expect(comment.beginToken, same(comment.endToken));
+    expect(comment.beginToken.lexeme, expectedText);
+  }
+
   void _expectDottedName(DottedName name, List<String> expectedComponents) {
     int count = expectedComponents.length;
     NodeList<SimpleIdentifier> components = name.components;
     expect(components, hasLength(count));
     for (int i = 0; i < count; i++) {
       SimpleIdentifier component = components[i];
       expect(component, isNotNull);
       expect(component.name, expectedComponents[i]);
     }
   }
@@ skipping 68 matching lines @@
   CompilationUnit _parseDirectives(String source,
       [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
     createParser(source);
     CompilationUnit unit = parser.parseDirectives2();
     expect(unit, isNotNull);
     expect(unit.declarations, hasLength(0));
     listener.assertErrorsWithCodes(errorCodes);
     return unit;
   }
 }