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

pkg/analyzer/test/src/summary/linker_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 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/link.dart';
 import 'package:test/test.dart';
@@ skipping 181 matching lines @@
 class C extends B {
   var c;
 }
 ''');
     LibraryElementForLink library = linker.getLibrary(linkerInputs.testDartUri);
     library.libraryCycleForLink.ensureLinked();
     // No assertions--just make sure it doesn't crash.
   }
 
   void test_bundle_refers_to_bundle() {
-    var bundle1 = createPackageBundle(
-        '''
+    var bundle1 = createPackageBundle('''
 var x = 0;
-''',
-        path: '/a.dart');
+''', path: '/a.dart');
     addBundle('/a.ds', bundle1);
-    var bundle2 = createPackageBundle(
-        '''
+    var bundle2 = createPackageBundle('''
 import "a.dart";
 var y = x;
-''',
-        path: '/b.dart');
+''', path: '/b.dart');
     expect(bundle2.dependencies, hasLength(1));
     expect(bundle2.dependencies[0].summaryPath, '/a.ds');
     expect(bundle2.dependencies[0].apiSignature, bundle1.apiSignature);
     addBundle('/a.ds', bundle1);
     addBundle('/b.ds', bundle2);
     createLinker('''
 import "b.dart";
 var z = y;
 ''');
     LibraryElementForLink library = linker.getLibrary(linkerInputs.testDartUri);
@@ skipping 35 matching lines @@
     expect(parameterAFT.isCovariant, isTrue);
     expect(parameterAFT.inheritsCovariant, isFalse);
     ClassElementForLink classB = testLibrary.getContainedName('B');
     MethodElementForLink methodBF = classB.getContainedName('f');
     ParameterElementForLink parameterBFT = methodBF.parameters[0];
     expect(parameterAFT.isCovariant, isTrue);
     expect(parameterBFT.inheritsCovariant, isTrue);
   }
 
   void test_createPackageBundle_withPackageUri() {
-    PackageBundle bundle = createPackageBundle(
-        '''
+    PackageBundle bundle = createPackageBundle('''
 class B {
   void f(int i) {}
 }
 class C extends B {
   f(i) {} // Inferred param type: int
 }
-''',
-        uri: 'package:foo/bar.dart');
+''', uri: 'package:foo/bar.dart');
     UnlinkedExecutable cf = bundle.unlinkedUnits[0].classes[1].executables[0];
     UnlinkedParam cfi = cf.parameters[0];
     expect(cfi.inferredTypeSlot, isNot(0));
     EntityRef typeRef = _lookupInferredType(
         bundle.linkedLibraries[0].units[0], cfi.inferredTypeSlot);
     expect(typeRef, isNotNull);
     expect(bundle.unlinkedUnits[0].references[typeRef.reference].name, 'int');
   }
 
   void test_getContainedName_nonStaticField() {
@@ skipping 18 matching lines @@
   }
 
   void test_getContainedName_nonStaticSetter() {
     createLinker('class C { void set s(value) {} }');
     LibraryElementForLink library = linker.getLibrary(linkerInputs.testDartUri);
     ClassElementForLink_Class c = library.getContainedName('C');
     expect(c.getContainedName('s='), isNot(isUndefined));
   }
 
   void test_inferredType_closure_fromBundle() {
-    var bundle = createPackageBundle(
-        '''
+    var bundle = createPackageBundle('''
 var x = () {};
-''',
-        path: '/a.dart');
+''', path: '/a.dart');
     addBundle('/a.ds', bundle);
     createLinker('''
 import 'a.dart';
 var y = x;
 ''');
     LibraryElementForLink library = linker.getLibrary(linkerInputs.testDartUri);
     expect(_getVariable(library.getContainedName('y')).inferredType.toString(),
         '() → dynamic');
   }
 
   void test_inferredType_closure_fromBundle_identifierSequence() {
-    var bundle = createPackageBundle(
-        '''
+    var bundle = createPackageBundle('''
 class C {
   static final x = (D d) => d.e;
 }
 class D {
   E e;
 }
 class E {}
-''',
-        path: '/a.dart');
+''', path: '/a.dart');
     addBundle('/a.ds', bundle);
     createLinker('''
 import 'a.dart';
 var y = C.x;
 ''');
     LibraryElementForLink library = linker.getLibrary(linkerInputs.testDartUri);
     expect(_getVariable(library.getContainedName('y')).inferredType.toString(),
         '(D) → dynamic');
   }
 
   void test_inferredType_implicitFunctionTypeIndices() {
-    var bundle = createPackageBundle(
-        '''
+    var bundle = createPackageBundle('''
 class A {
   void foo(void bar(int arg)) {}
 }
 class B extends A {
   void foo(bar) {}
 }
-''',
-        path: '/a.dart');
+''', path: '/a.dart');
     addBundle('/a.ds', bundle);
     createLinker('''
 import 'a.dart';
 class C extends B {
   void foo(bar) {}
 }
 ''');
     LibraryElementForLink library = linker.getLibrary(linkerInputs.testDartUri);
     library.libraryCycleForLink.ensureLinked();
     ClassElementForLink_Class cls = library.getContainedName('C');
@@ skipping 77 matching lines @@
 }
 ''');
     LibraryElementForLink library = linker.getLibrary(linkerInputs.testDartUri);
     library.libraryCycleForLink.ensureLinked();
     ClassElementForLink_Class cls = library.getContainedName('C');
     expect(cls.methods, hasLength(1));
     expect(cls.methods[0].returnType.toString(), 'void');
   }
 
   void test_inferredType_parameter_genericFunctionType() {
-    var bundle = createPackageBundle(
-        '''
+    var bundle = createPackageBundle('''
 class A<T> {
   A<R> map<R>(R Function(T) f) => null;
 }
-''',
-        path: '/a.dart');
+''', path: '/a.dart');
     addBundle('/a.ds', bundle);
     createLinker('''
 import 'a.dart';
 class C extends A<int> {
   map<R2>(f) => null;
 }
 ''');
     LibraryElementForLink library = linker.getLibrary(linkerInputs.testDartUri);
     library.libraryCycleForLink.ensureLinked();
     ClassElementForLink_Class c = library.getContainedName('C');
@@ skipping 30 matching lines @@
     expect(
         _getVariable(linker
                 .getLibrary(linkerInputs.testDartUri)
                 .getContainedName('y'))
             .inferredType
             .toString(),
         'dynamic');
   }
 
   void test_inferredTypeFromOutsideBuildUnit_dynamic() {
-    var bundle = createPackageBundle(
-        '''
+    var bundle = createPackageBundle('''
 var x;
 var y = x; // Inferred type: dynamic
-''',
-        path: '/a.dart');
+''', path: '/a.dart');
     addBundle('/a.ds', bundle);
     createLinker('''
 import 'a.dart';
 var z = y; // Inferred type: dynamic
 ''');
     LibraryElementForLink library = linker.getLibrary(linkerInputs.testDartUri);
     expect(_getVariable(library.getContainedName('z')).inferredType.toString(),
         'dynamic');
   }
 
   void test_inferredTypeFromOutsideBuildUnit_instanceField() {
-    var bundle = createPackageBundle(
-        '''
+    var bundle = createPackageBundle('''
 class C {
   var f = 0; // Inferred type: int
 }
-''',
-        path: '/a.dart');
+''', path: '/a.dart');
     addBundle('/a.ds', bundle);
     createLinker('''
 import 'a.dart';
 var x = new C().f; // Inferred type: dynamic
 ''');
     LibraryElementForLink library = linker.getLibrary(linkerInputs.testDartUri);
     expect(_getVariable(library.getContainedName('x')).inferredType.toString(),
         'dynamic');
   }
 
   void test_inferredTypeFromOutsideBuildUnit_instanceField_toInstanceField() {
-    var bundle = createPackageBundle(
-        '''
+    var bundle = createPackageBundle('''
 class C {
   var f = 0; // Inferred type: int
 }
-''',
-        path: '/a.dart');
+''', path: '/a.dart');
     addBundle('/a.ds', bundle);
     createLinker('''
 import 'a.dart';
 class D {
   var g = new C().f; // Inferred type: dynamic
 }
 ''');
     LibraryElementForLink library = linker.getLibrary(linkerInputs.testDartUri);
     ClassElementForLink_Class classD = library.getContainedName('D');
     expect(classD.fields[0].inferredType.toString(), 'dynamic');
   }
 
   void test_inferredTypeFromOutsideBuildUnit_methodParamType_viaInheritance() {
-    var bundle = createPackageBundle(
-        '''
+    var bundle = createPackageBundle('''
 class B {
   void f(int i) {}
 }
 class C extends B {
   f(i) {} // Inferred param type: int
 }
-''',
-        path: '/a.dart');
+''', path: '/a.dart');
     addBundle('/a.ds', bundle);
     createLinker('''
 import 'a.dart';
 class D extends C {
   f(i) {} // Inferred param type: int
 }
 ''');
     LibraryElementForLink library = linker.getLibrary(linkerInputs.testDartUri);
     library.libraryCycleForLink.ensureLinked();
     ClassElementForLink_Class cls = library.getContainedName('D');
     expect(cls.methods, hasLength(1));
     var method = cls.methods[0];
     expect(method.parameters, hasLength(1));
     expect(method.parameters[0].type.toString(), 'int');
   }
 
   void test_inferredTypeFromOutsideBuildUnit_methodReturnType_viaCall() {
-    var bundle = createPackageBundle(
-        '''
+    var bundle = createPackageBundle('''
 class B {
   int f() => 0;
 }
 class C extends B {
   f() => 1; // Inferred return type: int
 }
-''',
-        path: '/a.dart');
+''', path: '/a.dart');
     addBundle('/a.ds', bundle);
     createLinker('''
 import 'a.dart';
 var x = new C().f(); // Inferred type: int
 ''');
     LibraryElementForLink library = linker.getLibrary(linkerInputs.testDartUri);
     expect(_getVariable(library.getContainedName('x')).inferredType.toString(),
         'int');
   }
 
   void test_inferredTypeFromOutsideBuildUnit_methodReturnType_viaInheritance() {
-    var bundle = createPackageBundle(
-        '''
+    var bundle = createPackageBundle('''
 class B {
   int f() => 0;
 }
 class C extends B {
   f() => 1; // Inferred return type: int
 }
-''',
-        path: '/a.dart');
+''', path: '/a.dart');
     addBundle('/a.ds', bundle);
     createLinker('''
 import 'a.dart';
 class D extends C {
   f() => 2; //Inferred return type: int
 }
 ''');
     LibraryElementForLink library = linker.getLibrary(linkerInputs.testDartUri);
     library.libraryCycleForLink.ensureLinked();
     ClassElementForLink_Class cls = library.getContainedName('D');
@@ skipping 347 matching lines @@
    */
   EntityRef _lookupInferredType(LinkedUnit unit, int slot) {
     for (EntityRef ref in unit.types) {
       if (ref.slot == slot) {
         return ref;
       }
     }
     return null;
   }
 }