Format everything in analyzer

pkg/analyzer/test/generated/resolver_test_case.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.resolver_test_case;
 
 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 502 matching lines @@
    */
   LibraryElementImpl createDefaultTestLibrary() =>
       createTestLibrary(AnalysisContextFactory.contextWithCore(), "test");
 
   /**
    * Create a source object representing a file with the given [fileName] and
    * give it an empty content. Return the source that was created.
    */
   FileBasedSource createNamedSource(String fileName) {
     FileBasedSource source =
-    new FileBasedSource(FileUtilities2.createFile(fileName));
+        new FileBasedSource(FileUtilities2.createFile(fileName));
     analysisContext2.setContents(source, "");
     return source;
   }
 
   /**
    * Create a library element that represents a library with the given name containing a single
    * empty compilation unit.
    *
    * @param libraryName the name of the library to be created
    * @return the library element that was created
    */
   LibraryElementImpl createTestLibrary(
       AnalysisContext context, String libraryName,
       [List<String> typeNames]) {
     String fileName = "$libraryName.dart";
-    FileBasedSource definingCompilationUnitSource =
-    createNamedSource(fileName);
+    FileBasedSource definingCompilationUnitSource = createNamedSource(fileName);
     List<CompilationUnitElement> sourcedCompilationUnits;
     if (typeNames == null) {
       sourcedCompilationUnits = CompilationUnitElement.EMPTY_LIST;
     } else {
       int count = typeNames.length;
       sourcedCompilationUnits = new List<CompilationUnitElement>(count);
       for (int i = 0; i < count; i++) {
         String typeName = typeNames[i];
         ClassElementImpl type =
-        new ClassElementImpl.forNode(AstFactory.identifier3(typeName));
+            new ClassElementImpl.forNode(AstFactory.identifier3(typeName));
         String fileName = "$typeName.dart";
         CompilationUnitElementImpl compilationUnit =
-        new CompilationUnitElementImpl(fileName);
+            new CompilationUnitElementImpl(fileName);
         compilationUnit.source = createNamedSource(fileName);
         compilationUnit.librarySource = definingCompilationUnitSource;
         compilationUnit.types = <ClassElement>[type];
         sourcedCompilationUnits[i] = compilationUnit;
       }
     }
     CompilationUnitElementImpl compilationUnit =
-    new CompilationUnitElementImpl(fileName);
+        new CompilationUnitElementImpl(fileName);
     compilationUnit.librarySource =
         compilationUnit.source = definingCompilationUnitSource;
     LibraryElementImpl library = new LibraryElementImpl.forNode(
         context, AstFactory.libraryIdentifier2([libraryName]));
     library.definingCompilationUnit = compilationUnit;
     library.parts = sourcedCompilationUnits;
     return library;
   }
 
   /**
@@ skipping 20 matching lines @@
       // Is there a better exception to throw here? The point is that an
       // assertion failure here should be a failure, in both "test_*" and
       // "fail_*" tests. However, an assertion failure is success for the
       // purpose of "fail_*" tests, so without catching them here "fail_*" tests
       // can succeed by failing for the wrong reason.
       throw new JavaException("Unexexpected assertion failure: $exception");
     }
   }
 
   Expression findTopLevelConstantExpression(
-      CompilationUnit compilationUnit, String name) =>
+          CompilationUnit compilationUnit, String name) =>
       findTopLevelDeclaration(compilationUnit, name).initializer;
 
   VariableDeclaration findTopLevelDeclaration(
       CompilationUnit compilationUnit, String name) {
     for (CompilationUnitMember member in compilationUnit.declarations) {
       if (member is TopLevelVariableDeclaration) {
         for (VariableDeclaration variable in member.variables.variables) {
           if (variable.name.name == name) {
             return variable;
           }
@@ skipping 36 matching lines @@
 
   /**
    * Return the resolved compilation unit corresponding to the given source in the given library.
    *
    * @param source the source of the compilation unit to be returned
    * @param library the library in which the compilation unit is to be resolved
    * @return the resolved compilation unit
    * @throws Exception if the compilation unit could not be resolved
    */
   CompilationUnit resolveCompilationUnit(
-      Source source, LibraryElement library) =>
+          Source source, LibraryElement library) =>
       analysisContext2.resolveCompilationUnit(source, library);
 
   CompilationUnit resolveSource(String sourceText) =>
       resolveSource2("/test.dart", sourceText);
 
   CompilationUnit resolveSource2(String fileName, String sourceText) {
     Source source = addNamedSource(fileName, sourceText);
     LibraryElement library = analysisContext.computeLibraryElement(source);
     return analysisContext.resolveCompilationUnit(source, library);
   }
 
   Source resolveSources(List<String> sourceTexts) {
     for (int i = 0; i < sourceTexts.length; i++) {
       CompilationUnit unit =
-      resolveSource2("/lib${i + 1}.dart", sourceTexts[i]);
+          resolveSource2("/lib${i + 1}.dart", sourceTexts[i]);
       // reference the source if this is the last source
       if (i + 1 == sourceTexts.length) {
         return unit.element.source;
       }
     }
     return null;
   }
 
   void resolveWithAndWithoutExperimental(
       List<String> strSources,
@@ skipping 108 matching lines @@
    * If [type] is a string, validates that the identifier's static type
    * stringifies to that text. Otherwise, [type] is used directly a [Matcher]
    * to match the type.
    *
    * If [propagatedType] is given, also validate's the identifier's propagated
    * type.
    */
   void expectInitializerType(String name, type, [propagatedType]) {
     SimpleIdentifier identifier = findIdentifier(name);
     VariableDeclaration declaration =
-    identifier.getAncestor((node) => node is VariableDeclaration);
+        identifier.getAncestor((node) => node is VariableDeclaration);
     Expression initializer = declaration.initializer;
     _expectType(initializer.staticType, type);
     if (propagatedType != null) {
       _expectType(initializer.propagatedType, propagatedType);
     }
   }
 
   SimpleIdentifier findIdentifier(String search) {
     SimpleIdentifier identifier = EngineTestCase.findNode(
         testUnit, testCode, search, (node) => node is SimpleIdentifier);
@@ skipping 16 matching lines @@
    * text. Otherwise, [expected] is used directly a [Matcher] to match the type.
    */
   _expectType(DartType type, expected) {
     if (expected is String) {
       expect(type.toString(), expected);
     } else {
       expect(type, expected);
     }
   }
 }