Format analyzer, analysis_server, analyzer_plugin, front_end and kernel with the latest dartfmt.

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.
 
 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';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
@@ skipping 2423 matching lines @@
   }
 
   void test_emptyEnumBody() {
     createParser('enum E {}');
     EnumDeclaration declaration = parseFullCompilationUnitMember();
     expectNotNullIfNoErrors(declaration);
     listener.assertErrorsWithCodes([ParserErrorCode.EMPTY_ENUM_BODY]);
   }
 
   void test_enumInClass() {
-    parseCompilationUnit(
-        r'''
+    parseCompilationUnit(r'''
 class Foo {
   enum Bar {
     Bar1, Bar2, Bar3
   }
 }
-''',
-        [ParserErrorCode.ENUM_IN_CLASS]);
+''', [ParserErrorCode.ENUM_IN_CLASS]);
   }
 
   void test_equalityCannotBeEqualityOperand_eq_eq() {
     parseExpression(
         "1 == 2 == 3", [ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND]);
   }
 
   void test_equalityCannotBeEqualityOperand_eq_neq() {
     parseExpression(
         "1 == 2 != 3", [ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND]);
@@ skipping 1627 matching lines @@
   void test_topLevelVariable_withMetadata() {
     parseCompilationUnit("String @A string;", [
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.EXPECTED_TOKEN,
       ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE
     ]);
   }
 
   void test_typedef_incomplete() {
     // TODO(brianwilkerson) Improve recovery for this case.
-    parseCompilationUnit(
-        '''
+    parseCompilationUnit('''
 class A {}
 class B extends A {}
 
 typedef T
 
 main() {
   Function<
 }
-''',
-        [
-          ParserErrorCode.EXPECTED_TOKEN,
-          ParserErrorCode.UNEXPECTED_TOKEN,
-          ParserErrorCode.EXPECTED_EXECUTABLE
-        ]);
+''', [
+      ParserErrorCode.EXPECTED_TOKEN,
+      ParserErrorCode.UNEXPECTED_TOKEN,
+      ParserErrorCode.EXPECTED_EXECUTABLE
+    ]);
   }
 
   void test_typedef_namedFunction() {
     // TODO(brianwilkerson) Improve recovery for this case.
     parseCompilationUnit('typedef void Function();', [
       ParserErrorCode.UNEXPECTED_TOKEN,
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.EXPECTED_EXECUTABLE,
       ParserErrorCode.MISSING_TYPEDEF_PARAMETERS
     ]);
@@ skipping 52 matching lines @@
   }
 
   void test_unexpectedToken_semicolonBetweenCompilationUnitMembers() {
     parseCompilationUnit("int x; ; int y;", [ParserErrorCode.UNEXPECTED_TOKEN]);
   }
 
   void test_unterminatedString_at_eof() {
     // Although the "unterminated string" error message is produced by the
     // scanner, we need to verify that the parser can handle the tokens
     // produced by the scanner when an unterminated string is encountered.
-    parseCompilationUnit(
-        r'''
+    parseCompilationUnit(r'''
 void main() {
-  var x = "''',
-        [
-          ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
-          fe.Scanner.useFasta
-              ? ScannerErrorCode.EXPECTED_TOKEN
-              : ParserErrorCode.EXPECTED_TOKEN,
-          ParserErrorCode.EXPECTED_TOKEN
-        ]);
+  var x = "''', [
+      ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
+      fe.Scanner.useFasta
+          ? ScannerErrorCode.EXPECTED_TOKEN
+          : ParserErrorCode.EXPECTED_TOKEN,
+      ParserErrorCode.EXPECTED_TOKEN
+    ]);
   }
 
   void test_unterminatedString_at_eol() {
     // Although the "unterminated string" error message is produced by the
     // scanner, we need to verify that the parser can handle the tokens
     // produced by the scanner when an unterminated string is encountered.
-    parseCompilationUnit(
-        r'''
+    parseCompilationUnit(r'''
 void main() {
   var x = "
 ;
 }
-''',
-        [ScannerErrorCode.UNTERMINATED_STRING_LITERAL]);
+''', [ScannerErrorCode.UNTERMINATED_STRING_LITERAL]);
   }
 
   void test_unterminatedString_multiline_at_eof_3_quotes() {
     // Although the "unterminated string" error message is produced by the
     // scanner, we need to verify that the parser can handle the tokens
     // produced by the scanner when an unterminated string is encountered.
-    parseCompilationUnit(
-        r'''
+    parseCompilationUnit(r'''
 void main() {
-  var x = """''',
-        [
-          ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
-          fe.Scanner.useFasta
-              ? ScannerErrorCode.EXPECTED_TOKEN
-              : ParserErrorCode.EXPECTED_TOKEN,
-          ParserErrorCode.EXPECTED_TOKEN
-        ]);
+  var x = """''', [
+      ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
+      fe.Scanner.useFasta
+          ? ScannerErrorCode.EXPECTED_TOKEN
+          : ParserErrorCode.EXPECTED_TOKEN,
+      ParserErrorCode.EXPECTED_TOKEN
+    ]);
   }
 
   void test_unterminatedString_multiline_at_eof_4_quotes() {
     // Although the "unterminated string" error message is produced by the
     // scanner, we need to verify that the parser can handle the tokens
     // produced by the scanner when an unterminated string is encountered.
-    parseCompilationUnit(
-        r'''
+    parseCompilationUnit(r'''
 void main() {
-  var x = """"''',
-        [
-          ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
-          fe.Scanner.useFasta
-              ? ScannerErrorCode.EXPECTED_TOKEN
-              : ParserErrorCode.EXPECTED_TOKEN,
-          ParserErrorCode.EXPECTED_TOKEN
-        ]);
+  var x = """"''', [
+      ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
+      fe.Scanner.useFasta
+          ? ScannerErrorCode.EXPECTED_TOKEN
+          : ParserErrorCode.EXPECTED_TOKEN,
+      ParserErrorCode.EXPECTED_TOKEN
+    ]);
   }
 
   void test_unterminatedString_multiline_at_eof_5_quotes() {
     // Although the "unterminated string" error message is produced by the
     // scanner, we need to verify that the parser can handle the tokens
     // produced by the scanner when an unterminated string is encountered.
-    parseCompilationUnit(
-        r'''
+    parseCompilationUnit(r'''
 void main() {
-  var x = """""''',
-        [
-          ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
-          fe.Scanner.useFasta
-              ? ScannerErrorCode.EXPECTED_TOKEN
-              : ParserErrorCode.EXPECTED_TOKEN,
-          ParserErrorCode.EXPECTED_TOKEN
-        ]);
+  var x = """""''', [
+      ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
+      fe.Scanner.useFasta
+          ? ScannerErrorCode.EXPECTED_TOKEN
+          : ParserErrorCode.EXPECTED_TOKEN,
+      ParserErrorCode.EXPECTED_TOKEN
+    ]);
   }
 
   void test_useOfUnaryPlusOperator() {
     createParser('+x');
     Expression expression = parser.parseUnaryExpression();
     expectNotNullIfNoErrors(expression);
     listener.assertErrorsWithCodes([ParserErrorCode.MISSING_IDENTIFIER]);
     var identifier = expression as SimpleIdentifier;
     expect(identifier.isSynthetic, isTrue);
   }
@@ skipping 4663 matching lines @@
   void test_bitwiseXorExpression_super() {
     BinaryExpression expression = parseExpression("super ^  ^", [
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
     EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
         BinaryExpression, expression.leftOperand);
   }
 
   void test_classTypeAlias_withBody() {
-    parseCompilationUnit(
-        r'''
+    parseCompilationUnit(r'''
 class A {}
-class B = Object with A {}''',
-        [ParserErrorCode.EXPECTED_TOKEN]);
+class B = Object with A {}''', [ParserErrorCode.EXPECTED_TOKEN]);
   }
 
   void test_conditionalExpression_missingElse() {
     createParser('x ? y :');
     Expression expression = parser.parseConditionalExpression();
     expectNotNullIfNoErrors(expression);
     listener.assertErrorsWithCodes([ParserErrorCode.MISSING_IDENTIFIER]);
     expect(expression, new isInstanceOf<ConditionalExpression>());
     ConditionalExpression conditionalExpression = expression;
     expect(conditionalExpression.elseExpression,
@@ skipping 283 matching lines @@
     EngineTestCase.assertInstanceOf((obj) => obj is TopLevelVariableDeclaration,
         TopLevelVariableDeclaration, member);
     NodeList<VariableDeclaration> variables =
         (member as TopLevelVariableDeclaration).variables.variables;
     expect(variables, hasLength(1));
     SimpleIdentifier name = variables[0].name;
     expect(name.isSynthetic, isTrue);
   }
 
   void test_incompleteField_const() {
-    CompilationUnit unit = parseCompilationUnit(
-        r'''
+    CompilationUnit unit = parseCompilationUnit(r'''
 class C {
   const
-}''',
-        [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN]);
+}''', [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN]);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(1));
     CompilationUnitMember unitMember = declarations[0];
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ClassDeclaration, ClassDeclaration, unitMember);
     NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
     expect(members, hasLength(1));
     ClassMember classMember = members[0];
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FieldDeclaration, FieldDeclaration, classMember);
     VariableDeclarationList fieldList =
         (classMember as FieldDeclaration).fields;
     expect(fieldList.keyword.keyword, Keyword.CONST);
     NodeList<VariableDeclaration> fields = fieldList.variables;
     expect(fields, hasLength(1));
     VariableDeclaration field = fields[0];
     expect(field.name.isSynthetic, isTrue);
   }
 
   void test_incompleteField_final() {
-    CompilationUnit unit = parseCompilationUnit(
-        r'''
+    CompilationUnit unit = parseCompilationUnit(r'''
 class C {
   final
-}''',
-        [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN]);
+}''', [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN]);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(1));
     CompilationUnitMember unitMember = declarations[0];
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ClassDeclaration, ClassDeclaration, unitMember);
     NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
     expect(members, hasLength(1));
     ClassMember classMember = members[0];
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FieldDeclaration, FieldDeclaration, classMember);
     VariableDeclarationList fieldList =
         (classMember as FieldDeclaration).fields;
     expect(fieldList.keyword.keyword, Keyword.FINAL);
     NodeList<VariableDeclaration> fields = fieldList.variables;
     expect(fields, hasLength(1));
     VariableDeclaration field = fields[0];
     expect(field.name.isSynthetic, isTrue);
   }
 
   void test_incompleteField_var() {
-    CompilationUnit unit = parseCompilationUnit(
-        r'''
+    CompilationUnit unit = parseCompilationUnit(r'''
 class C {
   var
-}''',
-        [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN]);
+}''', [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN]);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(1));
     CompilationUnitMember unitMember = declarations[0];
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ClassDeclaration, ClassDeclaration, unitMember);
     NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
     expect(members, hasLength(1));
     ClassMember classMember = members[0];
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FieldDeclaration, FieldDeclaration, classMember);
@@ skipping 47 matching lines @@
   }
 
   void test_incompleteLocalVariable_parameterizedType() {
     Statement statement = parseStatement('List<String> v {}');
     assertErrorsWithCodes([ParserErrorCode.EXPECTED_TOKEN]);
     expect(statement, new isInstanceOf<VariableDeclarationStatement>());
     expect(statement.toSource(), 'List<String> v;');
   }
 
   void test_incompleteTypeArguments_field() {
-    CompilationUnit unit = parseCompilationUnit(
-        r'''
+    CompilationUnit unit = parseCompilationUnit(r'''
 class C {
   final List<int f;
-}''',
-        [ParserErrorCode.EXPECTED_TOKEN]);
+}''', [ParserErrorCode.EXPECTED_TOKEN]);
     // one class
     List<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(1));
     ClassDeclaration classDecl = declarations[0] as ClassDeclaration;
     // one field declaration
     List<ClassMember> members = classDecl.members;
     expect(members, hasLength(1));
     FieldDeclaration fieldDecl = members[0] as FieldDeclaration;
     // one field
     VariableDeclarationList fieldList = fieldDecl.fields;
     List<VariableDeclaration> fields = fieldList.variables;
     expect(fields, hasLength(1));
     VariableDeclaration field = fields[0];
     expect(field.name.name, 'f');
     // validate the type
     TypeArgumentList typeArguments = (fieldList.type as TypeName).typeArguments;
     expect(typeArguments.arguments, hasLength(1));
     // synthetic '>'
     Token token = typeArguments.endToken;
     expect(token.type, TokenType.GT);
     expect(token.isSynthetic, isTrue);
   }
 
   void test_incompleteTypeParameters() {
-    CompilationUnit unit = parseCompilationUnit(
-        r'''
+    CompilationUnit unit = parseCompilationUnit(r'''
 class C<K {
-}''',
-        [ParserErrorCode.EXPECTED_TOKEN]);
+}''', [ParserErrorCode.EXPECTED_TOKEN]);
     // one class
     List<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(1));
     ClassDeclaration classDecl = declarations[0] as ClassDeclaration;
     // validate the type parameters
     TypeParameterList typeParameters = classDecl.typeParameters;
     expect(typeParameters.typeParameters, hasLength(1));
     // synthetic '>'
     Token token = typeParameters.endToken;
     expect(token.type, TokenType.GT);
@@ skipping 139 matching lines @@
 
   void test_missingComma_beforeNamedArgument() {
     createParser('(a b: c)');
     ArgumentList argumentList = parser.parseArgumentList();
     expectNotNullIfNoErrors(argumentList);
     listener.assertErrorsWithCodes([ParserErrorCode.EXPECTED_TOKEN]);
     expect(argumentList.arguments, hasLength(2));
   }
 
   void test_missingGet() {
-    CompilationUnit unit = parseCompilationUnit(
-        r'''
+    CompilationUnit unit = parseCompilationUnit(r'''
 class C {
   int length {}
   void foo() {}
-}''',
-        [ParserErrorCode.MISSING_GET]);
+}''', [ParserErrorCode.MISSING_GET]);
     expect(unit, isNotNull);
     ClassDeclaration classDeclaration =
         unit.declarations[0] as ClassDeclaration;
     NodeList<ClassMember> members = classDeclaration.members;
     expect(members, hasLength(2));
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodDeclaration, MethodDeclaration, members[0]);
     ClassMember member = members[1];
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodDeclaration, MethodDeclaration, member);
@@ skipping 5598 matching lines @@
     expectCommentText(typeVariable.documentationComment, '/// Doc');
   }
 
   /**
    * Assert that the given [name] is in declaration context.
    */
   void _assertIsDeclarationName(SimpleIdentifier name) {
     expect(name.inDeclarationContext(), isTrue);
   }
 }