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

pkg/analyzer/test/src/dart/analysis/index_test.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.
 
 import 'dart:async';
 import 'dart:convert';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart';
@@ skipping 95 matching lines @@
 class A {} // 1
 class B extends A {} // 2
 ''');
     ClassElement elementA = findElement('A');
     assertThat(elementA)
       ..isExtendedAt('A {} // 2', false)
       ..isReferencedAt('A {} // 2', false);
   }
 
   test_isExtendedBy_ClassDeclaration_isQualified() async {
-    provider.newFile(
-        _p('$testProject/lib.dart'),
-        '''
+    provider.newFile(_p('$testProject/lib.dart'), '''
 class A {}
 ''');
     await _indexTestUnit('''
 import 'lib.dart' as p;
 class B extends p.A {} // 2
 ''');
     ClassElement elementA = importedUnit().getType('A');
     assertThat(elementA).isExtendedAt('A {} // 2', true);
   }
 
@@ skipping 12 matching lines @@
 class B {}
 class C = A with B;
 ''');
     ClassElement elementA = findElement('A');
     assertThat(elementA)
       ..isExtendedAt('A with', false)
       ..isReferencedAt('A with', false);
   }
 
   test_isExtendedBy_ClassTypeAlias_isQualified() async {
-    provider.newFile(
-        _p('$testProject/lib.dart'),
-        '''
+    provider.newFile(_p('$testProject/lib.dart'), '''
 class A {}
 ''');
     await _indexTestUnit('''
 import 'lib.dart' as p;
 class B {}
 class C = p.A with B;
 ''');
     ClassElement elementA = importedUnit().getType('A');
     assertThat(elementA)
       ..isExtendedAt('A with', true)
       ..isReferencedAt('A with', true);
   }
 
   test_isImplementedBy_ClassDeclaration() async {
     await _indexTestUnit('''
 class A {} // 1
 class B implements A {} // 2
 ''');
     ClassElement elementA = findElement('A');
     assertThat(elementA)
       ..isImplementedAt('A {} // 2', false)
       ..isReferencedAt('A {} // 2', false);
   }
 
   test_isImplementedBy_ClassDeclaration_isQualified() async {
-    provider.newFile(
-        _p('$testProject/lib.dart'),
-        '''
+    provider.newFile(_p('$testProject/lib.dart'), '''
 class A {}
 ''');
     await _indexTestUnit('''
 import 'lib.dart' as p;
 class B implements p.A {} // 2
 ''');
     ClassElement elementA = importedUnit().getType('A');
     assertThat(elementA)
       ..isImplementedAt('A {} // 2', true)
       ..isReferencedAt('A {} // 2', true);
@@ skipping 20 matching lines @@
     field(); // nq
   }
 }''');
     FieldElement field = findElement('field');
     assertThat(field.getter)
       ..isInvokedAt('field(); // q', true)
       ..isInvokedAt('field(); // nq', false);
   }
 
   test_isInvokedBy_FunctionElement() async {
-    provider.newFile(
-        _p('$testProject/lib.dart'),
-        '''
+    provider.newFile(_p('$testProject/lib.dart'), '''
 library lib;
 foo() {}
 ''');
     await _indexTestUnit('''
 import 'lib.dart';
 import 'lib.dart' as pref;
 main() {
   pref.foo(); // q
   foo(); // nq
 }''');
@@ skipping 116 matching lines @@
 class A {} // 1
 class B extends Object with A {} // 2
 ''');
     ClassElement elementA = findElement('A');
     assertThat(elementA)
       ..isMixedInAt('A {} // 2', false)
       ..isReferencedAt('A {} // 2', false);
   }
 
   test_isMixedInBy_ClassDeclaration_isQualified() async {
-    provider.newFile(
-        _p('$testProject/lib.dart'),
-        '''
+    provider.newFile(_p('$testProject/lib.dart'), '''
 class A {}
 ''');
     await _indexTestUnit('''
 import 'lib.dart' as p;
 class B extends Object with p.A {} // 2
 ''');
     ClassElement elementA = importedUnit().getType('A');
     assertThat(elementA).isMixedInAt('A {} // 2', true);
   }
 
@@ skipping 31 matching lines @@
     await _indexTestUnit('''
 class A {}
 main() {
   A(); // invalid code, but still a reference
 }''');
     Element element = findElement('A');
     assertThat(element).isReferencedAt('A();', false);
   }
 
   test_isReferencedBy_ClassElement_invocation_isQualified() async {
-    provider.newFile(
-        _p('$testProject/lib.dart'),
-        '''
+    provider.newFile(_p('$testProject/lib.dart'), '''
 class A {}
 ''');
     await _indexTestUnit('''
 import 'lib.dart' as p;
 main() {
   p.A(); // invalid code, but still a reference
 }''');
     Element element = importedUnit().getType('A');
     assertThat(element).isReferencedAt('A();', true);
   }
 
   test_isReferencedBy_ClassTypeAlias() async {
     await _indexTestUnit('''
 class A {}
 class B = Object with A;
 main(B p) {
   B v;
 }
 ''');
     ClassElement element = findElement('B');
     assertThat(element)
       ..isReferencedAt('B p) {', false)
       ..isReferencedAt('B v;', false);
   }
 
   test_isReferencedBy_CompilationUnitElement_export() async {
-    provider.newFile(
-        _p('$testProject/lib.dart'),
-        '''
+    provider.newFile(_p('$testProject/lib.dart'), '''
 library lib;
 ''');
     await _indexTestUnit('''
 export 'lib.dart';
 ''');
     LibraryElement element = testLibraryElement.exports[0].exportedLibrary;
     assertThat(element)..isReferencedAt("'lib.dart'", true, length: 10);
   }
 
   test_isReferencedBy_CompilationUnitElement_import() async {
-    provider.newFile(
-        _p('$testProject/lib.dart'),
-        '''
+    provider.newFile(_p('$testProject/lib.dart'), '''
 library lib;
 ''');
     await _indexTestUnit('''
 import 'lib.dart';
 ''');
     LibraryElement element = testLibraryElement.imports[0].importedLibrary;
     assertThat(element)..isReferencedAt("'lib.dart'", true, length: 10);
   }
 
   test_isReferencedBy_CompilationUnitElement_part() async {
     provider.newFile(_p('$testProject/my_unit.dart'), 'part of my_lib;');
     await _indexTestUnit('''
 library my_lib;
 part 'my_unit.dart';
 ''');
     CompilationUnitElement element = testLibraryElement.parts[0];
     assertThat(element)..isReferencedAt("'my_unit.dart';", true, length: 14);
   }
 
   test_isReferencedBy_CompilationUnitElement_part_inPart() async {
     provider.newFile(_p('$testProject/a.dart'), 'part of lib;');
-    provider.newFile(
-        _p('$testProject/b.dart'),
-        '''
+    provider.newFile(_p('$testProject/b.dart'), '''
 library lib;
 part 'a.dart';
 ''');
     await _indexTestUnit('''
 part 'b.dart';
 ''');
     // No exception, even though a.dart is a part of b.dart part.
   }
 
   test_isReferencedBy_ConstructorElement() async {
@@ skipping 245 matching lines @@
   print(foo());
 }
 ''');
     FunctionElement element = findElement('foo');
     assertThat(element)
       ..isReferencedAt('foo);', false)
       ..isInvokedAt('foo());', false);
   }
 
   test_isReferencedBy_FunctionElement_with_LibraryElement() async {
-    provider.newFile(
-        _p('$testProject/foo.dart'),
-        r'''
+    provider.newFile(_p('$testProject/foo.dart'), r'''
 bar() {}
 ''');
     await _indexTestUnit('''
 import "foo.dart";
 main() {
   bar();
 }
 ''');
     LibraryElement fooLibrary = testLibraryElement.imports[0].importedLibrary;
     assertThat(fooLibrary)..isReferencedAt('"foo.dart";', true, length: 10);
@@ skipping 72 matching lines @@
 int f2({int p}) => 2;
 main(bool b) {
   var f = b ? f1 : f2;
   f(p: 0);
 }''');
     // We should not crash because of reference to "p" - a named parameter
     // of a synthetic LUB FunctionElement created for "f".
   }
 
   test_isReferencedBy_TopLevelVariableElement() async {
-    provider.newFile(
-        _p('$testProject/lib.dart'),
-        '''
+    provider.newFile(_p('$testProject/lib.dart'), '''
 library lib;
 var V;
 ''');
     await _indexTestUnit('''
 import 'lib.dart' show V; // imp
 import 'lib.dart' as pref;
 main() {
   pref.V = 5; // q
   print(pref.V); // q
   V = 5; // nq
   print(V); // nq
 }''');
     TopLevelVariableElement variable = importedUnit().topLevelVariables[0];
     assertThat(variable)..isReferencedAt('V; // imp', true);
     assertThat(variable.getter)
       ..isReferencedAt('V); // q', true)
       ..isReferencedAt('V); // nq', false);
     assertThat(variable.setter)
       ..isReferencedAt('V = 5; // q', true)
       ..isReferencedAt('V = 5; // nq', false);
   }
 
   test_isReferencedBy_TopLevelVariableElement_synthetic_hasGetterSetter() async {
-    provider.newFile(
-        _p('$testProject/lib.dart'),
-        '''
+    provider.newFile(_p('$testProject/lib.dart'), '''
 int get V => 0;
 void set V(_) {}
 ''');
     await _indexTestUnit('''
 import 'lib.dart' show V;
 ''');
     TopLevelVariableElement element = importedUnit().topLevelVariables[0];
     assertThat(element).isReferencedAt('V;', true);
   }
 
   test_isReferencedBy_TopLevelVariableElement_synthetic_hasSetter() async {
-    provider.newFile(
-        _p('$testProject/lib.dart'),
-        '''
+    provider.newFile(_p('$testProject/lib.dart'), '''
 void set V(_) {}
 ''');
     await _indexTestUnit('''
 import 'lib.dart' show V;
 ''');
     TopLevelVariableElement element = importedUnit().topLevelVariables[0];
     assertThat(element).isReferencedAt('V;', true);
   }
 
   test_isReferencedBy_typeInVariableList() async {
@@ skipping 14 matching lines @@
 }
 ''');
     FieldElement element = findElement('field', ElementKind.FIELD);
     assertThat(element)
       ..isWrittenAt('field})', true)
       ..isWrittenAt('field = 5', true);
   }
 
   test_subtypes_classDeclaration() async {
     String libP = 'package:test/lib.dart;package:test/lib.dart';
-    provider.newFile(
-        _p('$testProject/lib.dart'),
-        '''
+    provider.newFile(_p('$testProject/lib.dart'), '''
 class A {}
 class B {}
 class C {}
 class D {}
 class E {}
 ''');
     await _indexTestUnit('''
 import 'lib.dart';
 
 class X extends A {
@@ skipping 36 matching lines @@
     {
       AnalysisDriverSubtype Z =
           index.subtypes.singleWhere((t) => t.name == 'Z');
       expect(Z.supertypes, ['$libP;D', '$libP;E']);
       expect(Z.members, ['methodZ']);
     }
   }
 
   test_subtypes_classTypeAlias() async {
     String libP = 'package:test/lib.dart;package:test/lib.dart';
-    provider.newFile(
-        _p('$testProject/lib.dart'),
-        '''
+    provider.newFile(_p('$testProject/lib.dart'), '''
 class A {}
 class B {}
 class C {}
 class D {}
 ''');
     await _indexTestUnit('''
 import 'lib.dart';
 
 class X = A with B, C;
 class Y = A with B implements C, D;
@@ skipping 367 matching lines @@
   final bool isQualified;
 
   _Relation(this.kind, this.offset, this.length, this.isQualified);
 
   @override
   String toString() {
     return '_Relation{kind: $kind, offset: $offset, length: $length, '
         'isQualified: $isQualified}lified)';
   }
 }