Format everything in analyzer

pkg/analyzer/test/generated/simple_resolver_test.dart

 // Copyright (c) 2016, 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.simple_resolver_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 33 matching lines @@
 void main() {
   new C().x += 1;
 }
 ''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     // Verify that both the getter and setter for "x" in "new C().x" refer to
     // the accessors defined in M2.
     FunctionDeclaration main =
-    library.definingCompilationUnit.functions[0].computeNode();
+        library.definingCompilationUnit.functions[0].computeNode();
     BlockFunctionBody body = main.functionExpression.body;
     ExpressionStatement stmt = body.block.statements[0];
     AssignmentExpression assignment = stmt.expression;
     PropertyAccess propertyAccess = assignment.leftHandSide;
     expect(
         propertyAccess.propertyName.staticElement.enclosingElement.name, 'M2');
     expect(
         propertyAccess
             .propertyName.auxiliaryElements.staticElement.enclosingElement.name,
         'M2');
@@ skipping 124 matching lines @@
 }''');
     LibraryElement library = resolve2(source);
     CompilationUnitElement unit = library.definingCompilationUnit;
     // find "a.sss = 0"
     AssignmentExpression assignment;
     {
       FunctionElement mainElement = unit.functions[0];
       FunctionBody mainBody = mainElement.computeNode().functionExpression.body;
       Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
       ExpressionStatement expressionStatement =
-      statement as ExpressionStatement;
+          statement as ExpressionStatement;
       assignment = expressionStatement.expression as AssignmentExpression;
     }
     // get parameter
     Expression rhs = assignment.rightHandSide;
     expect(rhs.staticParameterElement, isNull);
     ParameterElement parameter = rhs.propagatedParameterElement;
     expect(parameter, isNotNull);
     expect(parameter.displayName, "x");
     // validate
     ClassElement classA = unit.types[0];
@@ skipping 15 matching lines @@
 }''');
     LibraryElement library = resolve2(source);
     CompilationUnitElement unit = library.definingCompilationUnit;
     // find "a.b.sss = 0"
     AssignmentExpression assignment;
     {
       FunctionElement mainElement = unit.functions[0];
       FunctionBody mainBody = mainElement.computeNode().functionExpression.body;
       Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
       ExpressionStatement expressionStatement =
-      statement as ExpressionStatement;
+          statement as ExpressionStatement;
       assignment = expressionStatement.expression as AssignmentExpression;
     }
     // get parameter
     Expression rhs = assignment.rightHandSide;
     expect(rhs.staticParameterElement, isNull);
     ParameterElement parameter = rhs.propagatedParameterElement;
     expect(parameter, isNotNull);
     expect(parameter.displayName, "x");
     // validate
     ClassElement classB = unit.types[1];
@@ skipping 12 matching lines @@
 }''');
     LibraryElement library = resolve2(source);
     CompilationUnitElement unit = library.definingCompilationUnit;
     // find "a.sss = 0"
     AssignmentExpression assignment;
     {
       FunctionElement mainElement = unit.functions[0];
       FunctionBody mainBody = mainElement.computeNode().functionExpression.body;
       Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
       ExpressionStatement expressionStatement =
-      statement as ExpressionStatement;
+          statement as ExpressionStatement;
       assignment = expressionStatement.expression as AssignmentExpression;
     }
     // get parameter
     Expression rhs = assignment.rightHandSide;
     ParameterElement parameter = rhs.staticParameterElement;
     expect(parameter, isNotNull);
     expect(parameter.displayName, "x");
     // validate
     ClassElement classA = unit.types[0];
     PropertyAccessorElement setter = classA.accessors[0];
@@ skipping 14 matching lines @@
 }''');
     LibraryElement library = resolve2(source);
     CompilationUnitElement unit = library.definingCompilationUnit;
     // find "a.b.sss = 0"
     AssignmentExpression assignment;
     {
       FunctionElement mainElement = unit.functions[0];
       FunctionBody mainBody = mainElement.computeNode().functionExpression.body;
       Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
       ExpressionStatement expressionStatement =
-      statement as ExpressionStatement;
+          statement as ExpressionStatement;
       assignment = expressionStatement.expression as AssignmentExpression;
     }
     // get parameter
     Expression rhs = assignment.rightHandSide;
     ParameterElement parameter = rhs.staticParameterElement;
     expect(parameter, isNotNull);
     expect(parameter.displayName, "x");
     // validate
     ClassElement classB = unit.types[1];
     PropertyAccessorElement setter = classB.accessors[0];
@@ skipping 10 matching lines @@
       break loop1;
       break loop2;
     }
   }
 }
 ''';
     CompilationUnit unit = resolveSource(text);
     WhileStatement whileStatement = EngineTestCase.findNode(
         unit, text, 'while (true)', (n) => n is WhileStatement);
     ForStatement forStatement =
-    EngineTestCase.findNode(unit, text, 'for', (n) => n is ForStatement);
+        EngineTestCase.findNode(unit, text, 'for', (n) => n is ForStatement);
     BreakStatement break1 = EngineTestCase.findNode(
         unit, text, 'break loop1', (n) => n is BreakStatement);
     BreakStatement break2 = EngineTestCase.findNode(
         unit, text, 'break loop2', (n) => n is BreakStatement);
     expect(break1.target, same(whileStatement));
     expect(break2.target, same(forStatement));
   }
 
   void test_breakTarget_unlabeledBreakFromDo() {
     String text = r'''
 void f() {
   do {
     break;
   } while (true);
 }
 ''';
     CompilationUnit unit = resolveSource(text);
     DoStatement doStatement =
-    EngineTestCase.findNode(unit, text, 'do', (n) => n is DoStatement);
+        EngineTestCase.findNode(unit, text, 'do', (n) => n is DoStatement);
     BreakStatement breakStatement = EngineTestCase.findNode(
         unit, text, 'break', (n) => n is BreakStatement);
     expect(breakStatement.target, same(doStatement));
   }
 
   void test_breakTarget_unlabeledBreakFromFor() {
     String text = r'''
 void f() {
   for (int i = 0; i < 10; i++) {
     break;
   }
 }
 ''';
     CompilationUnit unit = resolveSource(text);
     ForStatement forStatement =
-    EngineTestCase.findNode(unit, text, 'for', (n) => n is ForStatement);
+        EngineTestCase.findNode(unit, text, 'for', (n) => n is ForStatement);
     BreakStatement breakStatement = EngineTestCase.findNode(
         unit, text, 'break', (n) => n is BreakStatement);
     expect(breakStatement.target, same(forStatement));
   }
 
   void test_breakTarget_unlabeledBreakFromForEach() {
     String text = r'''
 void f() {
   for (x in []) {
     break;
@@ skipping 130 matching lines @@
       continue loop1;
       continue loop2;
     }
   }
 }
 ''';
     CompilationUnit unit = resolveSource(text);
     WhileStatement whileStatement = EngineTestCase.findNode(
         unit, text, 'while (true)', (n) => n is WhileStatement);
     ForStatement forStatement =
-    EngineTestCase.findNode(unit, text, 'for', (n) => n is ForStatement);
+        EngineTestCase.findNode(unit, text, 'for', (n) => n is ForStatement);
     ContinueStatement continue1 = EngineTestCase.findNode(
         unit, text, 'continue loop1', (n) => n is ContinueStatement);
     ContinueStatement continue2 = EngineTestCase.findNode(
         unit, text, 'continue loop2', (n) => n is ContinueStatement);
     expect(continue1.target, same(whileStatement));
     expect(continue2.target, same(forStatement));
   }
 
   void test_continueTarget_unlabeledContinueFromDo() {
     String text = r'''
 void f() {
   do {
     continue;
   } while (true);
 }
 ''';
     CompilationUnit unit = resolveSource(text);
     DoStatement doStatement =
-    EngineTestCase.findNode(unit, text, 'do', (n) => n is DoStatement);
+        EngineTestCase.findNode(unit, text, 'do', (n) => n is DoStatement);
     ContinueStatement continueStatement = EngineTestCase.findNode(
         unit, text, 'continue', (n) => n is ContinueStatement);
     expect(continueStatement.target, same(doStatement));
   }
 
   void test_continueTarget_unlabeledContinueFromFor() {
     String text = r'''
 void f() {
   for (int i = 0; i < 10; i++) {
     continue;
   }
 }
 ''';
     CompilationUnit unit = resolveSource(text);
     ForStatement forStatement =
-    EngineTestCase.findNode(unit, text, 'for', (n) => n is ForStatement);
+        EngineTestCase.findNode(unit, text, 'for', (n) => n is ForStatement);
     ContinueStatement continueStatement = EngineTestCase.findNode(
         unit, text, 'continue', (n) => n is ContinueStatement);
     expect(continueStatement.target, same(forStatement));
   }
 
   void test_continueTarget_unlabeledContinueFromForEach() {
     String text = r'''
 void f() {
   for (x in []) {
     continue;
@@ skipping 266 matching lines @@
 void main() {
   var y = new C().x;
 }
 ''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     // Verify that the getter for "x" in "new C().x" refers to the getter
     // defined in M2.
     FunctionDeclaration main =
-    library.definingCompilationUnit.functions[0].computeNode();
+        library.definingCompilationUnit.functions[0].computeNode();
     BlockFunctionBody body = main.functionExpression.body;
     VariableDeclarationStatement stmt = body.block.statements[0];
     PropertyAccess propertyAccess = stmt.variables.variables[0].initializer;
     expect(
         propertyAccess.propertyName.staticElement.enclosingElement.name, 'M2');
   }
 
   void test_getterAndSetterWithDifferentTypes() {
     Source source = addSource(r'''
 class A {
@@ skipping 337 matching lines @@
   void test_localVariable_types_invoked() {
     Source source = addSource(r'''
 const A = null;
 main() {
   var myVar = (int p) => 'foo';
   myVar(42);
 }''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     CompilationUnit unit =
-    analysisContext.resolveCompilationUnit(source, library);
+        analysisContext.resolveCompilationUnit(source, library);
     expect(unit, isNotNull);
     List<bool> found = [false];
     List<CaughtException> thrownException = new List<CaughtException>(1);
     unit.accept(new _SimpleResolverTest_localVariable_types_invoked(
         this, found, thrownException));
     if (thrownException[0] != null) {
       throw new AnalysisException(
           "Exception", new CaughtException(thrownException[0], null));
     }
     expect(found[0], isTrue);
@@ skipping 252 matching lines @@
 class C extends B with M1, M2 {}
 void main() {
   new C().f();
 }
 ''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     // Verify that the "f" in "new C().f()" refers to the "f" defined in M2.
     FunctionDeclaration main =
-    library.definingCompilationUnit.functions[0].computeNode();
+        library.definingCompilationUnit.functions[0].computeNode();
     BlockFunctionBody body = main.functionExpression.body;
     ExpressionStatement stmt = body.block.statements[0];
     MethodInvocation expr = stmt.expression;
     expect(expr.methodName.staticElement.enclosingElement.name, 'M2');
   }
 
   void test_method_fromMixins_bare_identifier() {
     Source source = addSource('''
 class B {}
 class M1 {
@@ skipping 34 matching lines @@
 void main() {
   new C().f();
 }
 ''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     // Verify that the call to f() in "new C().f()" refers to the method
     // defined in M2.
     FunctionDeclaration main =
-    library.definingCompilationUnit.functions[0].computeNode();
+        library.definingCompilationUnit.functions[0].computeNode();
     BlockFunctionBody body = main.functionExpression.body;
     ExpressionStatement stmt = body.block.statements[0];
     MethodInvocation invocation = stmt.expression;
     expect(invocation.methodName.staticElement.enclosingElement.name, 'M2');
   }
 
   void test_method_fromSuperclassMixin() {
     Source source = addSource(r'''
 class A {
   void m1() {}
@@ skipping 96 matching lines @@
 void main() {
   new C().x = 1;
 }
 ''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     // Verify that the setter for "x" in "new C().x" refers to the setter
     // defined in M2.
     FunctionDeclaration main =
-    library.definingCompilationUnit.functions[0].computeNode();
+        library.definingCompilationUnit.functions[0].computeNode();
     BlockFunctionBody body = main.functionExpression.body;
     ExpressionStatement stmt = body.block.statements[0];
     AssignmentExpression assignment = stmt.expression;
     PropertyAccess propertyAccess = assignment.leftHandSide;
     expect(
         propertyAccess.propertyName.staticElement.enclosingElement.name, 'M2');
   }
 
   void test_setter_inherited() {
     Source source = addSource(r'''
@@ skipping 45 matching lines @@
    *           valid
    */
   void _validateArgumentResolution(Source source, List<int> indices) {
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     ClassElement classElement = library.definingCompilationUnit.types[0];
     List<ParameterElement> parameters = classElement.methods[1].parameters;
     CompilationUnit unit = resolveCompilationUnit(source, library);
     expect(unit, isNotNull);
     ClassDeclaration classDeclaration =
-    unit.declarations[0] as ClassDeclaration;
+        unit.declarations[0] as ClassDeclaration;
     MethodDeclaration methodDeclaration =
-    classDeclaration.members[0] as MethodDeclaration;
+        classDeclaration.members[0] as MethodDeclaration;
     Block block = (methodDeclaration.body as BlockFunctionBody).block;
     ExpressionStatement statement = block.statements[0] as ExpressionStatement;
     MethodInvocation invocation = statement.expression as MethodInvocation;
     NodeList<Expression> arguments = invocation.argumentList.arguments;
     int argumentCount = arguments.length;
     expect(argumentCount, indices.length);
     for (int i = 0; i < argumentCount; i++) {
       Expression argument = arguments[i];
       ParameterElement element = argument.staticParameterElement;
       int index = indices[i];
@@ skipping 29 matching lines @@
         // check propagated type
         FunctionType propagatedType = node.propagatedType as FunctionType;
         expect(propagatedType.returnType, test.typeProvider.stringType);
       } on AnalysisException catch (e, stackTrace) {
         thrownException[0] = new CaughtException(e, stackTrace);
       }
     }
     return null;
   }
 }