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

pkg/analyzer/test/src/dart/element/element_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.src.dart.element.element_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/constant/value.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 35 matching lines @@
     defineReflectiveTests(PropertyAccessorElementImplTest);
     defineReflectiveTests(TopLevelVariableElementImplTest);
   });
 }
 
 @reflectiveTest
 class ClassElementImplTest extends EngineTestCase {
   void test_computeNode_ClassDeclaration() {
     AnalysisContextHelper contextHelper = new AnalysisContextHelper();
     AnalysisContext context = contextHelper.context;
-    Source source = contextHelper.addSource(
-        "/test.dart",
-        r'''
+    Source source = contextHelper.addSource("/test.dart", r'''
 class A {}
 @deprecated class B {}
 enum C {C1, C2, C3}
 @deprecated enum D {D1, D2, D3}''');
     // prepare CompilationUnitElement
     LibraryElement libraryElement = context.computeLibraryElement(source);
     CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
     // A
     {
       ClassElement elementA = unitElement.getType("A");
@@ skipping 32 matching lines @@
       EnumDeclaration nodeC = elementD.computeNode();
       expect(nodeC, isNotNull);
       expect(nodeC.name.name, "D");
       expect(nodeC.element, same(elementD));
     }
   }
 
   void test_computeNode_ClassTypeAlias() {
     AnalysisContextHelper contextHelper = new AnalysisContextHelper();
     AnalysisContext context = contextHelper.context;
-    Source source = contextHelper.addSource(
-        "/test.dart",
-        r'''
+    Source source = contextHelper.addSource("/test.dart", r'''
 abstract class A<K, V> = Object with MapMixin<K, V>;
 ''');
     // prepare CompilationUnitElement
     LibraryElement libraryElement = context.computeLibraryElement(source);
     CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
     // A
     {
       ClassElement elementA = unitElement.getType("A");
       ClassTypeAlias nodeA = elementA.computeNode();
       expect(nodeA, isNotNull);
@@ skipping 877 matching lines @@
     String className = "C";
     ClassElement classElement = ElementFactory.classElement2(className);
     unit.types = <ClassElement>[classElement];
     expect(unit.getType("${className}x"), isNull);
   }
 }
 
 @reflectiveTest
 class ElementAnnotationImplTest extends ResolverTestCase {
   void test_computeConstantValue() {
-    addNamedSource(
-        '/a.dart',
-        r'''
+    addNamedSource('/a.dart', r'''
 class A {
   final String f;
   const A(this.f);
 }
 void f(@A('x') int p) {}
 ''');
     Source source = addSource(r'''
 import 'a.dart';
 main() {
   f(3);
@@ skipping 175 matching lines @@
     ElementLocationImpl second = new ElementLocationImpl.con2(encoding);
     expect(first.hashCode == second.hashCode, isTrue);
   }
 }
 
 @reflectiveTest
 class FieldElementImplTest extends EngineTestCase {
   void test_computeNode() {
     AnalysisContextHelper contextHelper = new AnalysisContextHelper();
     AnalysisContext context = contextHelper.context;
-    Source source = contextHelper.addSource(
-        "/test.dart",
-        r'''
+    Source source = contextHelper.addSource("/test.dart", r'''
 class A {
   int a;
 }
 enum B {B1, B2, B3}''');
     // prepare CompilationUnitElement
     LibraryElement libraryElement = context.computeLibraryElement(source);
     CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
     // A
     {
       FieldElement elementA = unitElement.getType("A").getField('a');
       VariableDeclaration nodeA = elementA.computeNode();
       expect(nodeA, isNotNull);
       expect(nodeA.name.name, "a");
       expect(nodeA.element, same(elementA));
     }
     // B
     {
       FieldElement elementB = unitElement.getEnum("B").getField('B2');
       EnumConstantDeclaration nodeB = elementB.computeNode();
       expect(nodeB, isNotNull);
       expect(nodeB.name.name, "B2");
       expect(nodeB.element, same(elementB));
     }
   }
 
   void test_isEnumConstant() {
     AnalysisContextHelper contextHelper = new AnalysisContextHelper();
     AnalysisContext context = contextHelper.context;
-    Source source = contextHelper.addSource(
-        "/test.dart",
-        r'''
+    Source source = contextHelper.addSource("/test.dart", r'''
 enum B {B1, B2, B3}
 ''');
     // prepare CompilationUnitElement
     LibraryElement libraryElement = context.computeLibraryElement(source);
     CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
 
     FieldElement b2Element = unitElement.getEnum("B").getField('B2');
     expect(b2Element.isEnumConstant, isTrue);
 
     FieldElement indexElement = unitElement.getEnum("B").getField('index');
@@ skipping 2583 matching lines @@
 }
 
 @reflectiveTest
 class LocalVariableElementImplTest extends EngineTestCase {}
 
 @reflectiveTest
 class MethodElementImplTest extends EngineTestCase {
   void test_computeNode() {
     AnalysisContextHelper contextHelper = new AnalysisContextHelper();
     AnalysisContext context = contextHelper.context;
-    Source source = contextHelper.addSource(
-        "/test.dart",
-        r'''
+    Source source = contextHelper.addSource("/test.dart", r'''
 abstract class A {
   String m1() => null;
   m2();
 }
 ''');
     // prepare CompilationUnitElement
     LibraryElement libraryElement = context.computeLibraryElement(source);
     CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
     // m1
     {
@@ skipping 11 matching lines @@
       expect(m2Node.name.name, "m2");
       expect(m2Node.element, same(m2Element));
     }
   }
 
   void test_computeNode_withoutFunctionBody() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.analyzeFunctionBodies = false;
     AnalysisContextHelper contextHelper = new AnalysisContextHelper(options);
     AnalysisContext context = contextHelper.context;
-    Source source = contextHelper.addSource(
-        "/test.dart",
-        r'''
+    Source source = contextHelper.addSource("/test.dart", r'''
 abstract class A {
   String m1() => null;
   m2();
 }
 ''');
     // prepare CompilationUnitElement
     LibraryElement libraryElement = context.computeLibraryElement(source);
     CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
     // m1
     {
@@ skipping 25 matching lines @@
   void setUp() {
     super.setUp();
     _typeProvider = new TestTypeProvider();
   }
 
   void test_getReifiedType_substituteFor() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.analyzeFunctionBodies = false;
     AnalysisContextHelper contextHelper = new AnalysisContextHelper(options);
     AnalysisContext context = contextHelper.context;
-    Source source = contextHelper.addSource(
-        "/test.dart",
-        r'''
+    Source source = contextHelper.addSource("/test.dart", r'''
 class A<T> {
   T f(T x) => x;
 }
 class B<S> extends A<S> {
   S f(S x) => x;
 }
 ''');
     // prepare CompilationUnitElement
     LibraryElement libraryElement = context.computeLibraryElement(source);
     CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
@@ skipping 69 matching lines @@
     library.definingCompilationUnit = compilationUnit;
     compilationUnit.topLevelVariables = variables;
   }
 }
 
 @reflectiveTest
 class ParameterElementImplTest extends EngineTestCase {
   void test_computeNode_DefaultFormalParameter() {
     AnalysisContextHelper contextHelper = new AnalysisContextHelper();
     AnalysisContext context = contextHelper.context;
-    Source source = contextHelper.addSource(
-        "/test.dart",
-        r'''
+    Source source = contextHelper.addSource("/test.dart", r'''
 main([int p = 42]) {
 }''');
     // prepare CompilationUnitElement
     LibraryElement libraryElement = context.computeLibraryElement(source);
     CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
     // p
     {
       ParameterElement element = unitElement.functions[0].parameters[0];
       DefaultFormalParameter node = element.computeNode();
       expect(node, isNotNull);
       expect(node.identifier.name, 'p');
       expect(node.element, same(element));
     }
   }
 
   void test_computeNode_FieldFormalParameter() {
     AnalysisContextHelper contextHelper = new AnalysisContextHelper();
     AnalysisContext context = contextHelper.context;
-    Source source = contextHelper.addSource(
-        "/test.dart",
-        r'''
+    Source source = contextHelper.addSource("/test.dart", r'''
 class A {
   int p;
   A(this.p) {
   }
 }''');
     // prepare CompilationUnitElement
     LibraryElement libraryElement = context.computeLibraryElement(source);
     CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
     // p
     {
       ClassElement classA = unitElement.types[0];
       ConstructorElement constructorA = classA.constructors[0];
       FieldFormalParameterElement element = constructorA.parameters[0];
       FieldFormalParameter node = element.computeNode();
       expect(node, isNotNull);
       expect(node.identifier.name, 'p');
       expect(node.element, same(element));
     }
   }
 
   void test_computeNode_FunctionTypedFormalParameter() {
     AnalysisContextHelper contextHelper = new AnalysisContextHelper();
     AnalysisContext context = contextHelper.context;
-    Source source = contextHelper.addSource(
-        "/test.dart",
-        r'''
+    Source source = contextHelper.addSource("/test.dart", r'''
 main(p(int a, int b)) {
 }''');
     // prepare CompilationUnitElement
     LibraryElement libraryElement = context.computeLibraryElement(source);
     CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
     // p
     {
       ParameterElement element = unitElement.functions[0].parameters[0];
       FunctionTypedFormalParameter node = element.computeNode();
       expect(node, isNotNull);
       expect(node.identifier.name, 'p');
       expect(node.element, same(element));
     }
   }
 
   void test_computeNode_SimpleFormalParameter() {
     AnalysisContextHelper contextHelper = new AnalysisContextHelper();
     AnalysisContext context = contextHelper.context;
-    Source source = contextHelper.addSource(
-        "/test.dart",
-        r'''
+    Source source = contextHelper.addSource("/test.dart", r'''
 main(int p) {
 }''');
     // prepare CompilationUnitElement
     LibraryElement libraryElement = context.computeLibraryElement(source);
     CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
     // p
     {
       ParameterElement element = unitElement.functions[0].parameters[0];
       SimpleFormalParameter node = element.computeNode();
       expect(node, isNotNull);
@@ skipping 44 matching lines @@
 
   @override
   Element getElement(ElementLocation location) {
     return locationMap[location];
   }
 }
 
 @reflectiveTest
 class TopLevelVariableElementImplTest extends ResolverTestCase {
   void test_computeConstantValue() {
-    addNamedSource(
-        '/a.dart',
-        r'''
+    addNamedSource('/a.dart', r'''
 const int C = 42;
 ''');
     Source source = addSource(r'''
 import 'a.dart';
 main() {
   print(C);
 }
 ''');
     LibraryElement library = resolve2(source);
     CompilationUnit unit = resolveCompilationUnit(source, library);
@@ skipping 213 matching lines @@
 }
 
 class _FunctionTypeImplTest_isSubtypeOf_baseCase_classFunction
     extends InterfaceTypeImpl {
   _FunctionTypeImplTest_isSubtypeOf_baseCase_classFunction(ClassElement arg0)
       : super(arg0);
 
   @override
   bool get isDartCoreFunction => true;
 }