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

pkg/analyzer_plugin/test/utilities/analyzer_converter_test.dart

 // Copyright (c) 2017, 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:analyzer/dart/ast/ast.dart' as analyzer;
 import 'package:analyzer/dart/element/element.dart' as analyzer;
 import 'package:analyzer/dart/element/type.dart' as analyzer;
 import 'package:analyzer/error/error.dart' as analyzer;
 import 'package:analyzer/exception/exception.dart' as analyzer;
 import 'package:analyzer/source/error_processor.dart' as analyzer;
@@ skipping 163 matching lines @@
     ];
 
     List<plugin.AnalysisError> pluginErrors =
         converter.convertAnalysisErrors(analyzerErrors, options: options);
     expect(pluginErrors, hasLength(analyzerErrors.length));
     assertError(pluginErrors[0], analyzerErrors[0], severity: severity);
     assertError(pluginErrors[1], analyzerErrors[1], severity: severity);
   }
 
   test_convertElement_class() async {
-    analyzer.Source source = addSource(
-        testFile,
-        '''
+    analyzer.Source source = addSource(testFile, '''
 @deprecated
 abstract class _A {}
 class B<K, V> {}''');
     analyzer.CompilationUnit unit = await resolveLibraryUnit(source);
     {
       analyzer.ClassElement engineElement = findElementInUnit(unit, '_A');
       // create notification Element
       plugin.Element element = converter.convertElement(engineElement);
       expect(element.kind, plugin.ElementKind.CLASS);
       expect(element.name, '_A');
@@ skipping 18 matching lines @@
       // create notification Element
       plugin.Element element = converter.convertElement(engineElement);
       expect(element.kind, plugin.ElementKind.CLASS);
       expect(element.name, 'B');
       expect(element.typeParameters, '<K, V>');
       expect(element.flags, 0);
     }
   }
 
   test_convertElement_constructor() async {
-    analyzer.Source source = addSource(
-        testFile,
-        '''
+    analyzer.Source source = addSource(testFile, '''
 class A {
   const A.myConstructor(int a, [String b]);
 }''');
     analyzer.CompilationUnit unit = await resolveLibraryUnit(source);
     analyzer.ConstructorElement engineElement =
         findElementInUnit(unit, 'myConstructor');
     // create notification Element
     plugin.Element element = converter.convertElement(engineElement);
     expect(element.kind, plugin.ElementKind.CONSTRUCTOR);
     expect(element.name, 'myConstructor');
@@ skipping 17 matching lines @@
     plugin.Element element = converter.convertElement(engineElement);
     expect(element.kind, plugin.ElementKind.UNKNOWN);
     expect(element.name, 'dynamic');
     expect(element.location, isNull);
     expect(element.parameters, isNull);
     expect(element.returnType, isNull);
     expect(element.flags, 0);
   }
 
   test_convertElement_enum() async {
-    analyzer.Source source = addSource(
-        testFile,
-        '''
+    analyzer.Source source = addSource(testFile, '''
 @deprecated
 enum _E1 { one, two }
 enum E2 { three, four }''');
     analyzer.CompilationUnit unit = await resolveLibraryUnit(source);
     {
       analyzer.ClassElement engineElement = findElementInUnit(unit, '_E1');
       expect(engineElement.isDeprecated, isTrue);
       // create notification Element
       plugin.Element element = converter.convertElement(engineElement);
       expect(element.kind, plugin.ElementKind.ENUM);
@@ skipping 18 matching lines @@
       // create notification Element
       plugin.Element element = converter.convertElement(engineElement);
       expect(element.kind, plugin.ElementKind.ENUM);
       expect(element.name, 'E2');
       expect(element.typeParameters, isNull);
       expect(element.flags, 0);
     }
   }
 
   test_convertElement_enumConstant() async {
-    analyzer.Source source = addSource(
-        testFile,
-        '''
+    analyzer.Source source = addSource(testFile, '''
 @deprecated
 enum _E1 { one, two }
 enum E2 { three, four }''');
     analyzer.CompilationUnit unit = await resolveLibraryUnit(source);
     {
       analyzer.FieldElement engineElement = findElementInUnit(unit, 'one');
       // create notification Element
       plugin.Element element = converter.convertElement(engineElement);
       expect(element.kind, plugin.ElementKind.ENUM_CONSTANT);
       expect(element.name, 'one');
@@ skipping 70 matching lines @@
         expect(location.startColumn, 0);
       }
       expect(element.parameters, isNull);
       expect(element.returnType, 'List<E2>');
       expect(element.flags,
           plugin.Element.FLAG_CONST | plugin.Element.FLAG_STATIC);
     }
   }
 
   test_convertElement_field() async {
-    analyzer.Source source = addSource(
-        testFile,
-        '''
+    analyzer.Source source = addSource(testFile, '''
 class A {
   static const myField = 42;
 }''');
     analyzer.CompilationUnit unit = await resolveLibraryUnit(source);
     analyzer.FieldElement engineElement = findElementInUnit(unit, 'myField');
     // create notification Element
     plugin.Element element = converter.convertElement(engineElement);
     expect(element.kind, plugin.ElementKind.FIELD);
     expect(element.name, 'myField');
     {
       plugin.Location location = element.location;
       expect(location.file, testFile);
       expect(location.offset, 25);
       expect(location.length, 'myField'.length);
       expect(location.startLine, 2);
       expect(location.startColumn, 16);
     }
     expect(element.parameters, isNull);
     expect(element.returnType, 'dynamic');
     expect(
         element.flags, plugin.Element.FLAG_CONST | plugin.Element.FLAG_STATIC);
   }
 
   test_convertElement_functionTypeAlias() async {
-    analyzer.Source source = addSource(
-        testFile,
-        '''
+    analyzer.Source source = addSource(testFile, '''
 typedef int F<T>(String x);
 ''');
     analyzer.CompilationUnit unit = await resolveLibraryUnit(source);
     analyzer.FunctionTypeAliasElement engineElement =
         findElementInUnit(unit, 'F');
     // create notification Element
     plugin.Element element = converter.convertElement(engineElement);
     expect(element.kind, plugin.ElementKind.FUNCTION_TYPE_ALIAS);
     expect(element.name, 'F');
     expect(element.typeParameters, '<T>');
     {
       plugin.Location location = element.location;
       expect(location.file, testFile);
       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_convertElement_getter() async {
-    analyzer.Source source = addSource(
-        testFile,
-        '''
+    analyzer.Source source = addSource(testFile, '''
 class A {
   String get myGetter => 42;
 }''');
     analyzer.CompilationUnit unit = await resolveLibraryUnit(source);
     analyzer.PropertyAccessorElement engineElement =
         findElementInUnit(unit, 'myGetter', analyzer.ElementKind.GETTER);
     // create notification Element
     plugin.Element element = converter.convertElement(engineElement);
     expect(element.kind, plugin.ElementKind.GETTER);
     expect(element.name, 'myGetter');
     {
       plugin.Location location = element.location;
       expect(location.file, testFile);
       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_convertElement_method() async {
-    analyzer.Source source = addSource(
-        testFile,
-        '''
+    analyzer.Source source = addSource(testFile, '''
 class A {
   static List<String> myMethod(int a, {String b, int c}) {
     return null;
   }
 }''');
     analyzer.CompilationUnit unit = await resolveLibraryUnit(source);
     analyzer.MethodElement engineElement = findElementInUnit(unit, 'myMethod');
     // create notification Element
     plugin.Element element = converter.convertElement(engineElement);
     expect(element.kind, plugin.ElementKind.METHOD);
     expect(element.name, 'myMethod');
     {
       plugin.Location location = element.location;
       expect(location.file, testFile);
       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, plugin.Element.FLAG_STATIC);
   }
 
   test_convertElement_setter() async {
-    analyzer.Source source = addSource(
-        testFile,
-        '''
+    analyzer.Source source = addSource(testFile, '''
 class A {
   set mySetter(String x) {}
 }''');
     analyzer.CompilationUnit unit = await resolveLibraryUnit(source);
     analyzer.PropertyAccessorElement engineElement =
         findElementInUnit(unit, 'mySetter', analyzer.ElementKind.SETTER);
     // create notification Element
     plugin.Element element = converter.convertElement(engineElement);
     expect(element.kind, plugin.ElementKind.SETTER);
     expect(element.name, 'mySetter');
@@ skipping 54 matching lines @@
     }
   }
 
   test_convertErrorType() {
     for (analyzer.ErrorType type in analyzer.ErrorType.values) {
       expect(converter.convertErrorType(type), isNotNull, reason: type.name);
     }
   }
 
   test_fromElement_LABEL() async {
-    analyzer.Source source = addSource(
-        testFile,
-        '''
+    analyzer.Source source = addSource(testFile, '''
 main() {
 myLabel:
   while (true) {
     break myLabel;
   }
 }''');
     analyzer.CompilationUnit unit = await resolveLibraryUnit(source);
     analyzer.LabelElement engineElement = findElementInUnit(unit, 'myLabel');
     // create notification Element
     plugin.Element element = converter.convertElement(engineElement);
     expect(element.kind, plugin.ElementKind.LABEL);
     expect(element.name, 'myLabel');
     {
       plugin.Location location = element.location;
       expect(location.file, testFile);
       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);
   }
 }