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

pkg/analysis_server/test/plugin/protocol_dart_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:analysis_server/plugin/protocol/protocol_dart.dart';
 import 'package:analyzer/dart/ast/ast.dart' as engine;
 import 'package:analyzer/dart/ast/visitor.dart' as engine;
 import 'package:analyzer/dart/element/element.dart' as engine;
 import 'package:analyzer/dart/element/type.dart' as engine;
 import 'package:analyzer/error/error.dart' as engine;
@@ skipping 86 matching lines @@
 @reflectiveTest
 class ElementTest extends AbstractContextTest {
   engine.Element findElementInUnit(engine.CompilationUnit unit, String name,
       [engine.ElementKind kind]) {
     return findElementsByName(unit, name)
         .where((e) => kind == null || e.kind == kind)
         .single;
   }
 
   test_fromElement_CLASS() async {
-    engine.Source source = addSource(
-        '/test.dart',
-        '''
+    engine.Source source = addSource('/test.dart', '''
 @deprecated
 abstract class _A {}
 class B<K, V> {}''');
     engine.CompilationUnit unit = await resolveLibraryUnit(source);
     {
       engine.ClassElement engineElement = findElementInUnit(unit, '_A');
       // create notification Element
       Element element = convertElement(engineElement);
       expect(element.kind, ElementKind.CLASS);
       expect(element.name, '_A');
@@ skipping 18 matching lines @@
       // create notification Element
       Element element = convertElement(engineElement);
       expect(element.kind, ElementKind.CLASS);
       expect(element.name, 'B');
       expect(element.typeParameters, '<K, V>');
       expect(element.flags, 0);
     }
   }
 
   test_fromElement_CONSTRUCTOR() async {
-    engine.Source source = addSource(
-        '/test.dart',
-        '''
+    engine.Source source = addSource('/test.dart', '''
 class A {
   const A.myConstructor(int a, [String b]);
 }''');
     engine.CompilationUnit unit = await resolveLibraryUnit(source);
     engine.ConstructorElement engineElement =
         findElementInUnit(unit, 'myConstructor');
     // create notification Element
     Element element = convertElement(engineElement);
     expect(element.kind, ElementKind.CONSTRUCTOR);
     expect(element.name, 'myConstructor');
@@ skipping 17 matching lines @@
     Element element = convertElement(engineElement);
     expect(element.kind, ElementKind.UNKNOWN);
     expect(element.name, 'dynamic');
     expect(element.location, isNull);
     expect(element.parameters, isNull);
     expect(element.returnType, isNull);
     expect(element.flags, 0);
   }
 
   test_fromElement_ENUM() async {
-    engine.Source source = addSource(
-        '/test.dart',
-        '''
+    engine.Source source = addSource('/test.dart', '''
 @deprecated
 enum _E1 { one, two }
 enum E2 { three, four }''');
     engine.CompilationUnit unit = await resolveLibraryUnit(source);
     {
       engine.ClassElement engineElement = findElementInUnit(unit, '_E1');
       expect(engineElement.isDeprecated, isTrue);
       // create notification Element
       Element element = convertElement(engineElement);
       expect(element.kind, ElementKind.ENUM);
@@ skipping 18 matching lines @@
       // create notification Element
       Element element = convertElement(engineElement);
       expect(element.kind, ElementKind.ENUM);
       expect(element.name, 'E2');
       expect(element.typeParameters, isNull);
       expect(element.flags, 0);
     }
   }
 
   test_fromElement_ENUM_CONSTANT() async {
-    engine.Source source = addSource(
-        '/test.dart',
-        '''
+    engine.Source source = addSource('/test.dart', '''
 @deprecated
 enum _E1 { one, two }
 enum E2 { three, four }''');
     engine.CompilationUnit unit = await resolveLibraryUnit(source);
     {
       engine.FieldElement engineElement = findElementInUnit(unit, 'one');
       // create notification Element
       Element element = convertElement(engineElement);
       expect(element.kind, ElementKind.ENUM_CONSTANT);
       expect(element.name, 'one');
@@ skipping 67 matching lines @@
         expect(location.startLine, 1);
         expect(location.startColumn, 0);
       }
       expect(element.parameters, isNull);
       expect(element.returnType, 'List<E2>');
       expect(element.flags, Element.FLAG_CONST | Element.FLAG_STATIC);
     }
   }
 
   test_fromElement_FIELD() async {
-    engine.Source source = addSource(
-        '/test.dart',
-        '''
+    engine.Source source = addSource('/test.dart', '''
 class A {
   static const myField = 42;
 }''');
     engine.CompilationUnit unit = await resolveLibraryUnit(source);
     engine.FieldElement engineElement = findElementInUnit(unit, 'myField');
     // create notification Element
     Element element = convertElement(engineElement);
     expect(element.kind, ElementKind.FIELD);
     expect(element.name, 'myField');
     {
       Location location = element.location;
       expect(location.file, '/test.dart');
       expect(location.offset, 25);
       expect(location.length, 'myField'.length);
       expect(location.startLine, 2);
       expect(location.startColumn, 16);
     }
     expect(element.parameters, isNull);
     expect(element.returnType, 'int');
     expect(element.flags, Element.FLAG_CONST | Element.FLAG_STATIC);
   }
 
   test_fromElement_FUNCTION_TYPE_ALIAS() async {
-    engine.Source source = addSource(
-        '/test.dart',
-        '''
+    engine.Source source = addSource('/test.dart', '''
 typedef int F<T>(String x);
 ''');
     engine.CompilationUnit unit = await resolveLibraryUnit(source);
     engine.FunctionTypeAliasElement engineElement =
         findElementInUnit(unit, 'F');
     // create notification Element
     Element element = convertElement(engineElement);
     expect(element.kind, ElementKind.FUNCTION_TYPE_ALIAS);
     expect(element.name, 'F');
     expect(element.typeParameters, '<T>');
     {
       Location location = element.location;
       expect(location.file, '/test.dart');
       expect(location.offset, 12);
       expect(location.length, 'F'.length);
       expect(location.startLine, 1);
       expect(location.startColumn, 13);
     }
     expect(element.parameters, '(String x)');
     expect(element.returnType, 'int');
     expect(element.flags, 0);
   }
 
   test_fromElement_GETTER() async {
-    engine.Source source = addSource(
-        '/test.dart',
-        '''
+    engine.Source source = addSource('/test.dart', '''
 class A {
   String get myGetter => 42;
 }''');
     engine.CompilationUnit unit = await resolveLibraryUnit(source);
     engine.PropertyAccessorElement engineElement =
         findElementInUnit(unit, 'myGetter', engine.ElementKind.GETTER);
     // create notification Element
     Element element = convertElement(engineElement);
     expect(element.kind, ElementKind.GETTER);
     expect(element.name, 'myGetter');
     {
       Location location = element.location;
       expect(location.file, '/test.dart');
       expect(location.offset, 23);
       expect(location.length, 'myGetter'.length);
       expect(location.startLine, 2);
       expect(location.startColumn, 14);
     }
     expect(element.parameters, isNull);
     expect(element.returnType, 'String');
     expect(element.flags, 0);
   }
 
   test_fromElement_LABEL() async {
-    engine.Source source = addSource(
-        '/test.dart',
-        '''
+    engine.Source source = addSource('/test.dart', '''
 main() {
 myLabel:
   while (true) {
     break myLabel;
   }
 }''');
     engine.CompilationUnit unit = await resolveLibraryUnit(source);
     engine.LabelElement engineElement = findElementInUnit(unit, 'myLabel');
     // create notification Element
     Element element = convertElement(engineElement);
     expect(element.kind, ElementKind.LABEL);
     expect(element.name, 'myLabel');
     {
       Location location = element.location;
       expect(location.file, '/test.dart');
       expect(location.offset, 9);
       expect(location.length, 'myLabel'.length);
       expect(location.startLine, 2);
       expect(location.startColumn, 1);
     }
     expect(element.parameters, isNull);
     expect(element.returnType, isNull);
     expect(element.flags, 0);
   }
 
   test_fromElement_METHOD() async {
-    engine.Source source = addSource(
-        '/test.dart',
-        '''
+    engine.Source source = addSource('/test.dart', '''
 class A {
   static List<String> myMethod(int a, {String b, int c}) {
     return null;
   }
 }''');
     engine.CompilationUnit unit = await resolveLibraryUnit(source);
     engine.MethodElement engineElement = findElementInUnit(unit, 'myMethod');
     // create notification Element
     Element element = convertElement(engineElement);
     expect(element.kind, ElementKind.METHOD);
     expect(element.name, 'myMethod');
     {
       Location location = element.location;
       expect(location.file, '/test.dart');
       expect(location.offset, 32);
       expect(location.length, 'myGetter'.length);
       expect(location.startLine, 2);
       expect(location.startColumn, 23);
     }
     expect(element.parameters, '(int a, {String b, int c})');
     expect(element.returnType, 'List<String>');
     expect(element.flags, Element.FLAG_STATIC);
   }
 
   test_fromElement_SETTER() async {
-    engine.Source source = addSource(
-        '/test.dart',
-        '''
+    engine.Source source = addSource('/test.dart', '''
 class A {
   set mySetter(String x) {}
 }''');
     engine.CompilationUnit unit = await resolveLibraryUnit(source);
     engine.PropertyAccessorElement engineElement =
         findElementInUnit(unit, 'mySetter', engine.ElementKind.SETTER);
     // create notification Element
     Element element = convertElement(engineElement);
     expect(element.kind, ElementKind.SETTER);
     expect(element.name, 'mySetter');
     {
       Location location = element.location;
       expect(location.file, '/test.dart');
       expect(location.offset, 16);
       expect(location.length, 'mySetter'.length);
       expect(location.startLine, 2);
       expect(location.startColumn, 7);
     }
     expect(element.parameters, '(String x)');
     expect(element.returnType, isNull);
     expect(element.flags, 0);
   }
 }