Format everything in analyzer

pkg/analyzer/test/generated/analysis_context_factory.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.analysis_context_factory;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 75 matching lines @@
     SourceFactory sourceFactory = new SourceFactory(resolvers);
     context.sourceFactory = sourceFactory;
     AnalysisContext coreContext = sdk.context;
     (coreContext.analysisOptions as AnalysisOptionsImpl).strongMode =
         context.analysisOptions.strongMode;
     //
     // dart:core
     //
     TestTypeProvider provider = new TestTypeProvider();
     CompilationUnitElementImpl coreUnit =
-    new CompilationUnitElementImpl("core.dart");
+        new CompilationUnitElementImpl("core.dart");
     Source coreSource = sourceFactory.forUri(DartSdk.DART_CORE);
     coreContext.setContents(coreSource, "");
     coreUnit.librarySource = coreUnit.source = coreSource;
     ClassElementImpl proxyClassElement = ElementFactory.classElement2("_Proxy");
     proxyClassElement.constructors = <ConstructorElement>[
       ElementFactory.constructorElement(proxyClassElement, '', true)
         ..isCycleFree = true
         ..constantInitializers = <ConstructorInitializer>[]
     ];
     ClassElement objectClassElement = provider.objectType.element;
@@ skipping 18 matching lines @@
     ];
     coreUnit.functions = <FunctionElement>[
       ElementFactory.functionElement3("identical", provider.boolType.element,
           <ClassElement>[objectClassElement, objectClassElement], null),
       ElementFactory.functionElement3("print", VoidTypeImpl.instance.element,
           <ClassElement>[objectClassElement], null)
     ];
     TopLevelVariableElement proxyTopLevelVariableElt = ElementFactory
         .topLevelVariableElement3("proxy", true, false, proxyClassElement.type);
     ConstTopLevelVariableElementImpl deprecatedTopLevelVariableElt =
-    ElementFactory.topLevelVariableElement3(
-        "deprecated", true, false, provider.deprecatedType);
+        ElementFactory.topLevelVariableElement3(
+            "deprecated", true, false, provider.deprecatedType);
     {
       ClassElement deprecatedElement = provider.deprecatedType.element;
       InstanceCreationExpression initializer = AstFactory
           .instanceCreationExpression2(
-          Keyword.CONST,
-          AstFactory.typeName(deprecatedElement),
-          [AstFactory.string2('next release')]);
+              Keyword.CONST,
+              AstFactory.typeName(deprecatedElement),
+              [AstFactory.string2('next release')]);
       ConstructorElement constructor = deprecatedElement.constructors.single;
       initializer.staticElement = constructor;
       initializer.constructorName.staticElement = constructor;
       deprecatedTopLevelVariableElt.constantInitializer = initializer;
     }
     coreUnit.accessors = <PropertyAccessorElement>[
       proxyTopLevelVariableElt.getter,
       deprecatedTopLevelVariableElt.getter
     ];
     coreUnit.topLevelVariables = <TopLevelVariableElement>[
       proxyTopLevelVariableElt,
       deprecatedTopLevelVariableElt
     ];
     LibraryElementImpl coreLibrary = new LibraryElementImpl.forNode(
         coreContext, AstFactory.libraryIdentifier2(["dart", "core"]));
     coreLibrary.definingCompilationUnit = coreUnit;
     //
     // dart:async
     //
     Source asyncSource;
     LibraryElementImpl asyncLibrary;
     if (context.analysisOptions.enableAsync) {
       asyncLibrary = new LibraryElementImpl.forNode(
           coreContext, AstFactory.libraryIdentifier2(["dart", "async"]));
       CompilationUnitElementImpl asyncUnit =
-      new CompilationUnitElementImpl("async.dart");
+          new CompilationUnitElementImpl("async.dart");
       asyncSource = sourceFactory.forUri(DartSdk.DART_ASYNC);
       coreContext.setContents(asyncSource, "");
       asyncUnit.librarySource = asyncUnit.source = asyncSource;
       asyncLibrary.definingCompilationUnit = asyncUnit;
       // Future
       ClassElementImpl futureElement =
-      ElementFactory.classElement2("Future", ["T"]);
+          ElementFactory.classElement2("Future", ["T"]);
       futureElement.enclosingElement = asyncUnit;
       //   factory Future.value([value])
       ConstructorElementImpl futureConstructor =
-      ElementFactory.constructorElement2(futureElement, "value");
+          ElementFactory.constructorElement2(futureElement, "value");
       futureConstructor.parameters = <ParameterElement>[
         ElementFactory.positionalParameter2("value", provider.dynamicType)
       ];
       futureConstructor.factory = true;
       futureElement.constructors = <ConstructorElement>[futureConstructor];
       //   Future then(onValue(T value), { Function onError });
       TypeDefiningElement futureThenR = DynamicElementImpl.instance;
       if (context.analysisOptions.strongMode) {
         futureThenR = ElementFactory.typeParameterWithType('R');
       }
@@ skipping 12 matching lines @@
       }
       thenOnValue.enclosingElement = thenMethod;
       thenOnValue.type = new FunctionTypeImpl(thenOnValue);
       (thenMethod.parameters[0] as ParameterElementImpl).type =
           thenOnValue.type;
       thenMethod.type = new FunctionTypeImpl(thenMethod);
 
       futureElement.methods = <MethodElement>[thenMethod];
       // Completer
       ClassElementImpl completerElement =
-      ElementFactory.classElement2("Completer", ["T"]);
+          ElementFactory.classElement2("Completer", ["T"]);
       ConstructorElementImpl completerConstructor =
-      ElementFactory.constructorElement2(completerElement, null);
+          ElementFactory.constructorElement2(completerElement, null);
       completerElement.constructors = <ConstructorElement>[
         completerConstructor
       ];
       // StreamSubscription
       ClassElementImpl streamSubscriptionElement =
-      ElementFactory.classElement2("StreamSubscription", ["T"]);
+          ElementFactory.classElement2("StreamSubscription", ["T"]);
       // Stream
       ClassElementImpl streamElement =
-      ElementFactory.classElement2("Stream", ["T"]);
+          ElementFactory.classElement2("Stream", ["T"]);
       streamElement.constructors = <ConstructorElement>[
         ElementFactory.constructorElement2(streamElement, null)
       ];
       DartType returnType = streamSubscriptionElement.type
           .instantiate(streamElement.type.typeArguments);
       FunctionElementImpl listenOnData = ElementFactory.functionElement3(
           'onData',
           VoidTypeImpl.instance.element,
           <TypeDefiningElement>[streamElement.typeParameters[0]],
           null);
       listenOnData.synthetic = true;
       List<DartType> parameterTypes = <DartType>[listenOnData.type,];
       // TODO(brianwilkerson) This is missing the optional parameters.
       MethodElementImpl listenMethod =
-      ElementFactory.methodElement('listen', returnType, parameterTypes);
+          ElementFactory.methodElement('listen', returnType, parameterTypes);
       streamElement.methods = <MethodElement>[listenMethod];
       listenMethod.type = new FunctionTypeImpl(listenMethod);
 
       FunctionElementImpl listenParamFunction = parameterTypes[0].element;
       listenParamFunction.enclosingElement = listenMethod;
       listenParamFunction.type = new FunctionTypeImpl(listenParamFunction);
       ParameterElementImpl listenParam = listenMethod.parameters[0];
       listenParam.type = listenParamFunction.type;
 
       asyncUnit.types = <ClassElement>[
         completerElement,
         futureElement,
         streamElement,
         streamSubscriptionElement
       ];
     }
     //
     // dart:html
     //
     CompilationUnitElementImpl htmlUnit =
-    new CompilationUnitElementImpl("html_dartium.dart");
+        new CompilationUnitElementImpl("html_dartium.dart");
     Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
     coreContext.setContents(htmlSource, "");
     htmlUnit.librarySource = htmlUnit.source = htmlSource;
     ClassElementImpl elementElement = ElementFactory.classElement2("Element");
     InterfaceType elementType = elementElement.type;
     ClassElementImpl canvasElement =
-    ElementFactory.classElement("CanvasElement", elementType);
+        ElementFactory.classElement("CanvasElement", elementType);
     ClassElementImpl contextElement =
-    ElementFactory.classElement2("CanvasRenderingContext");
+        ElementFactory.classElement2("CanvasRenderingContext");
     InterfaceType contextElementType = contextElement.type;
     ClassElementImpl context2dElement = ElementFactory.classElement(
         "CanvasRenderingContext2D", contextElementType);
     canvasElement.methods = <MethodElement>[
       ElementFactory.methodElement(
           "getContext", contextElementType, [provider.stringType])
     ];
     canvasElement.accessors = <PropertyAccessorElement>[
       ElementFactory.getterElement("context2D", false, context2dElement.type)
     ];
     canvasElement.fields = canvasElement.accessors
         .map((PropertyAccessorElement accessor) => accessor.variable)
         .toList();
     ClassElementImpl documentElement =
-    ElementFactory.classElement("Document", elementType);
+        ElementFactory.classElement("Document", elementType);
     ClassElementImpl htmlDocumentElement =
-    ElementFactory.classElement("HtmlDocument", documentElement.type);
+        ElementFactory.classElement("HtmlDocument", documentElement.type);
     htmlDocumentElement.methods = <MethodElement>[
       ElementFactory
           .methodElement("query", elementType, <DartType>[provider.stringType])
     ];
     htmlUnit.types = <ClassElement>[
       ElementFactory.classElement("AnchorElement", elementType),
       ElementFactory.classElement("BodyElement", elementType),
       ElementFactory.classElement("ButtonElement", elementType),
       canvasElement,
       contextElement,
       context2dElement,
       ElementFactory.classElement("DivElement", elementType),
       documentElement,
       elementElement,
       htmlDocumentElement,
       ElementFactory.classElement("InputElement", elementType),
       ElementFactory.classElement("SelectElement", elementType)
     ];
     htmlUnit.functions = <FunctionElement>[
       ElementFactory.functionElement3("query", elementElement,
           <ClassElement>[provider.stringType.element], ClassElement.EMPTY_LIST)
     ];
     TopLevelVariableElementImpl document =
-    ElementFactory.topLevelVariableElement3(
-        "document", false, true, htmlDocumentElement.type);
+        ElementFactory.topLevelVariableElement3(
+            "document", false, true, htmlDocumentElement.type);
     htmlUnit.topLevelVariables = <TopLevelVariableElement>[document];
     htmlUnit.accessors = <PropertyAccessorElement>[document.getter];
     LibraryElementImpl htmlLibrary = new LibraryElementImpl.forNode(
         coreContext, AstFactory.libraryIdentifier2(["dart", "dom", "html"]));
     htmlLibrary.definingCompilationUnit = htmlUnit;
     //
     // dart:math
     //
     CompilationUnitElementImpl mathUnit =
-    new CompilationUnitElementImpl("math.dart");
+        new CompilationUnitElementImpl("math.dart");
     Source mathSource = sourceFactory.forUri(_DART_MATH);
     coreContext.setContents(mathSource, "");
     mathUnit.librarySource = mathUnit.source = mathSource;
     FunctionElement cosElement = ElementFactory.functionElement3(
         "cos",
         provider.doubleType.element,
         <ClassElement>[provider.numType.element],
         ClassElement.EMPTY_LIST);
     TopLevelVariableElement ln10Element = ElementFactory
         .topLevelVariableElement3("LN10", true, false, provider.doubleType);
     TypeParameterElement maxT =
-    ElementFactory.typeParameterWithType('T', provider.numType);
+        ElementFactory.typeParameterWithType('T', provider.numType);
     FunctionElementImpl maxElement = ElementFactory.functionElement3(
         "max", maxT, [maxT, maxT], ClassElement.EMPTY_LIST);
     maxElement.typeParameters = [maxT];
     maxElement.type = new FunctionTypeImpl(maxElement);
     TopLevelVariableElement piElement = ElementFactory.topLevelVariableElement3(
         "PI", true, false, provider.doubleType);
     ClassElementImpl randomElement = ElementFactory.classElement2("Random");
     randomElement.abstract = true;
     ConstructorElementImpl randomConstructor =
-    ElementFactory.constructorElement2(randomElement, null);
+        ElementFactory.constructorElement2(randomElement, null);
     randomConstructor.factory = true;
     ParameterElementImpl seedParam = new ParameterElementImpl("seed", 0);
     seedParam.parameterKind = ParameterKind.POSITIONAL;
     seedParam.type = provider.intType;
     randomConstructor.parameters = <ParameterElement>[seedParam];
     randomElement.constructors = <ConstructorElement>[randomConstructor];
     FunctionElement sinElement = ElementFactory.functionElement3(
         "sin",
         provider.doubleType.element,
         <ClassElement>[provider.numType.element],
@@ skipping 25 matching lines @@
     // Set empty sources for the rest of the libraries.
     //
     Source source = sourceFactory.forUri(_DART_INTERCEPTORS);
     coreContext.setContents(source, "");
     source = sourceFactory.forUri(_DART_JS_HELPER);
     coreContext.setContents(source, "");
     //
     // Record the elements.
     //
     HashMap<Source, LibraryElement> elementMap =
-    new HashMap<Source, LibraryElement>();
+        new HashMap<Source, LibraryElement>();
     elementMap[coreSource] = coreLibrary;
     if (asyncSource != null) {
       elementMap[asyncSource] = asyncLibrary;
     }
     elementMap[htmlSource] = htmlLibrary;
     elementMap[mathSource] = mathLibrary;
     //
     // Set the public and export namespaces.  We don't use exports in the fake
     // core library so public and export namespaces are the same.
     //
     for (LibraryElementImpl library in elementMap.values) {
       Namespace namespace =
-      new NamespaceBuilder().createPublicNamespaceForLibrary(library);
+          new NamespaceBuilder().createPublicNamespaceForLibrary(library);
       library.exportNamespace = namespace;
       library.publicNamespace = namespace;
     }
     context.recordLibraryElements(elementMap);
     // Create the synthetic element for `loadLibrary`.
     for (LibraryElementImpl library in elementMap.values) {
       library.createLoadLibraryFunction(context.typeProvider);
     }
     return context;
   }
 }
 
 /**
  * An analysis context that has a fake SDK that is much smaller and faster for
  * testing purposes.
  */
 class AnalysisContextForTests extends AnalysisContextImpl {
   @override
   void set analysisOptions(AnalysisOptions options) {
     AnalysisOptions currentOptions = analysisOptions;
     bool needsRecompute = currentOptions.analyzeFunctionBodiesPredicate !=
-        options.analyzeFunctionBodiesPredicate ||
+            options.analyzeFunctionBodiesPredicate ||
         currentOptions.generateImplicitErrors !=
             options.generateImplicitErrors ||
         currentOptions.generateSdkErrors != options.generateSdkErrors ||
         currentOptions.dart2jsHint != options.dart2jsHint ||
         (currentOptions.hint && !options.hint) ||
         currentOptions.preserveComments != options.preserveComments ||
         currentOptions.enableStrictCallChecks != options.enableStrictCallChecks;
     if (needsRecompute) {
       fail(
           "Cannot set options that cause the sources to be reanalyzed in a test context");
@@ skipping 75 matching lines @@
     }
   }
 }
 
 class TestPackageUriResolver extends UriResolver {
   Map<Uri, Source> sourceMap = new HashMap<Uri, Source>();
 
   TestPackageUriResolver(Map<String, String> map) {
     map.forEach((String uri, String contents) {
       sourceMap[Uri.parse(uri)] =
-      new StringSource(contents, '/test_pkg_source.dart');
+          new StringSource(contents, '/test_pkg_source.dart');
     });
   }
 
   @override
   Source resolveAbsolute(Uri uri, [Uri actualUri]) => sourceMap[uri];
 
   @override
   Uri restoreAbsolute(Source source) => throw new UnimplementedError();
 }
 
@@ skipping 22 matching lines @@
 
   void _addLibrary(LibraryMap map, String uri, bool isInternal, String path) {
     SdkLibraryImpl library = new SdkLibraryImpl(uri);
     if (isInternal) {
       library.category = "Internal";
     }
     library.path = path;
     map.setLibrary(uri, library);
   }
 }