Parse RedirectingConstructorInvocation with Fasta.

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 89 matching lines @@
       [List<ErrorCode> errorCodes = const <ErrorCode>[]]);
 
   /// TODO(paulberry): merge with [parseCompilationUnit]
   CompilationUnit parseCompilationUnitWithOptions(String source,
       [List<ErrorCode> errorCodes = const <ErrorCode>[]]);
 
   ConditionalExpression parseConditionalExpression(String code);
 
   Expression parseConstExpression(String code);
 
+  ConstructorInitializer parseConstructorInitializer(String code);
+
   /**
    * Parse the given source as a compilation unit.
    *
    * @param source the source to be parsed
    * @param errorCodes the error codes of the errors that are expected to be found
    * @return the compilation unit that was parsed
    * @throws Exception if the source could not be parsed, if the compilation errors in the source do
    *           not match those that are expected, or if the result would have been `null`
    */
   CompilationUnit parseDirectives(String source,
@@ skipping 64 matching lines @@
   RethrowExpression parseRethrowExpression(String code);
 
   BinaryExpression parseShiftExpression(String code);
 
   SimpleIdentifier parseSimpleIdentifier(String code);
 
   Statement parseStatement(String source, [bool enableLazyAssignmentOperators]);
 
   Expression parseStringLiteral(String code);
 
-  SuperConstructorInvocation parseSuperConstructorInvocation(String code);
-
   SymbolLiteral parseSymbolLiteral(String code);
 
   Expression parseThrowExpression(String code);
 
   Expression parseThrowExpressionWithoutCascade(String code);
 
   PrefixExpression parseUnaryExpression(String code);
 }
 
 /**
@@ skipping 5741 matching lines @@
 
   void test_parsePrimaryExpression_true() {
     Expression expression = parsePrimaryExpression('true');
     expect(expression, isNotNull);
     assertNoErrors();
     var literal = expression as BooleanLiteral;
     expect(literal.literal, isNotNull);
     expect(literal.value, isTrue);
   }
 
+  void test_parseRedirectingConstructorInvocation_named() {
+    var invocation = parseConstructorInitializer('this.a()')
+        as RedirectingConstructorInvocation;
+    assertNoErrors();
+    expect(invocation.argumentList, isNotNull);
+    expect(invocation.constructorName, isNotNull);
+    expect(invocation.thisKeyword, isNotNull);
+    expect(invocation.period, isNotNull);
+  }
+
+  void test_parseRedirectingConstructorInvocation_unnamed() {
+    var invocation = parseConstructorInitializer('this()')
+        as RedirectingConstructorInvocation;
+    assertNoErrors();
+    expect(invocation.argumentList, isNotNull);
+    expect(invocation.constructorName, isNull);
+    expect(invocation.thisKeyword, isNotNull);
+    expect(invocation.period, isNull);
+  }
+
   void test_parseRelationalExpression_as_functionType_noReturnType() {
     Expression expression = parseRelationalExpression('x as Function(int)');
     expect(expression, isNotNull);
     assertNoErrors();
     var asExpression = expression as AsExpression;
     expect(asExpression.expression, isNotNull);
     expect(asExpression.asOperator, isNotNull);
     expect(asExpression.type, new isInstanceOf<GenericFunctionType>());
   }
 
@@ skipping 401 matching lines @@
     expect(
         interpolation.elements[1], new isInstanceOf<InterpolationExpression>());
     InterpolationExpression element1 = interpolation.elements[1];
     expect(element1.expression, new isInstanceOf<SimpleIdentifier>());
     expect(interpolation.elements[2], new isInstanceOf<InterpolationString>());
     InterpolationString element2 = interpolation.elements[2];
     expect(element2.value, 'y');
   }
 
   void test_parseSuperConstructorInvocation_named() {
-    SuperConstructorInvocation invocation =
-        parseSuperConstructorInvocation('super.a()');
+    var invocation =
+        parseConstructorInitializer('super.a()') as SuperConstructorInvocation;
     expect(invocation, isNotNull);
     assertNoErrors();
     expect(invocation.argumentList, isNotNull);
     expect(invocation.constructorName, isNotNull);
     expect(invocation.superKeyword, isNotNull);
     expect(invocation.period, isNotNull);
   }
 
   void test_parseSuperConstructorInvocation_unnamed() {
-    SuperConstructorInvocation invocation =
-        parseSuperConstructorInvocation('super()');
-    expect(invocation, isNotNull);
+    var invocation =
+        parseConstructorInitializer('super()') as SuperConstructorInvocation;
     assertNoErrors();
     expect(invocation.argumentList, isNotNull);
     expect(invocation.constructorName, isNull);
     expect(invocation.superKeyword, isNotNull);
     expect(invocation.period, isNull);
   }
 
   void test_parseSymbolLiteral_builtInIdentifier() {
     SymbolLiteral literal = parseSymbolLiteral('#dynamic.static.abstract');
     expect(literal, isNotNull);
@@ skipping 1622 matching lines @@
     return parser.parseConditionalExpression();
   }
 
   @override
   Expression parseConstExpression(String code) {
     createParser(code);
     return parser.parseConstExpression();
   }
 
   @override
+  ConstructorInitializer parseConstructorInitializer(String code) {
+    createParser('class __Test { __Test() : $code; }');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    var clazz = unit.declarations[0] as ClassDeclaration;
+    var constructor = clazz.members[0] as ConstructorDeclaration;
+    return constructor.initializers.single;
+  }
+
+  @override
   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;
   }
 
@@ skipping 243 matching lines @@
     return statements;
   }
 
   @override
   Expression parseStringLiteral(String code) {
     createParser(code);
     return parser.parseStringLiteral();
   }
 
   @override
-  SuperConstructorInvocation parseSuperConstructorInvocation(String code) {
-    createParser(code);
-    return parser.parseSuperConstructorInvocation();
-  }
-
-  @override
   SymbolLiteral parseSymbolLiteral(String code) {
     createParser(code);
     return parser.parseSymbolLiteral();
   }
 
   @override
   Expression parseThrowExpression(String code) {
     createParser(code);
     return parser.parseThrowExpression();
   }
@@ skipping 2912 matching lines @@
   }
 
   void test_parseOptionalReturnType() {
     // TODO(brianwilkerson) Implement tests for this method.
   }
 
   void test_Parser() {
     expect(new Parser(null, null), isNotNull);
   }
 
-  void test_parseRedirectingConstructorInvocation_named() {
-    createParser('this.a()');
-    RedirectingConstructorInvocation invocation =
-        parser.parseRedirectingConstructorInvocation(true);
-    expectNotNullIfNoErrors(invocation);
-    listener.assertNoErrors();
-    expect(invocation.argumentList, isNotNull);
-    expect(invocation.constructorName, isNotNull);
-    expect(invocation.thisKeyword, isNotNull);
-    expect(invocation.period, isNotNull);
-  }
-
-  void test_parseRedirectingConstructorInvocation_unnamed() {
-    createParser('this()');
-    RedirectingConstructorInvocation invocation =
-        parser.parseRedirectingConstructorInvocation(false);
-    expectNotNullIfNoErrors(invocation);
-    listener.assertNoErrors();
-    expect(invocation.argumentList, isNotNull);
-    expect(invocation.constructorName, isNull);
-    expect(invocation.thisKeyword, isNotNull);
-    expect(invocation.period, isNull);
-  }
-
   void test_parseReturnStatement_noValue() {
     createParser('return;');
     ReturnStatement statement = parser.parseReturnStatement();
     expectNotNullIfNoErrors(statement);
     listener.assertNoErrors();
     expect(statement.returnKeyword, isNotNull);
     expect(statement.expression, isNull);
     expect(statement.semicolon, isNotNull);
   }
 
@@ skipping 3503 matching lines @@
     expectCommentText(typeVariable.documentationComment, '/// Doc');
   }
 
   /**
    * Assert that the given [name] is in declaration context.
    */
   void _assertIsDeclarationName(SimpleIdentifier name) {
     expect(name.inDeclarationContext(), isTrue);
   }
 }