Issue 20827. Extract library importing helper and use it fox Quick Fixes.

pkg/analysis_server/test/services/correction/fix_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 test.services.correction.fix;
 
 import 'package:analysis_server/src/protocol.dart' hide AnalysisError;
 import 'package:analysis_server/src/services/correction/fix.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
@@ skipping 167 matching lines @@
     assertHasFix(FixKind.CHANGE_TO_STATIC_ACCESS, '''
 class A {
   static foo() {}
 }
 main(A a) {
   A.foo();
 }
 ''');
   }
 
+  void test_changeToStaticAccess_method_importType() {
+    addSource('/libA.dart', r'''
+library libA;
+class A {
+  static foo() {}
+}
+''');
+    addSource('/libB.dart', r'''
+library libB;
+import 'libA.dart';
+class B extends A {}
+''');
+    resolveTestUnit('''
+import 'libB.dart';
+main(B b) {
+  b.foo();
+}
+''');
+    assertHasFix(FixKind.CHANGE_TO_STATIC_ACCESS, '''
+import 'libB.dart';
+import 'libA.dart';
+main(B b) {
+  A.foo();
+}
+''');
+  }
+
   void test_changeToStaticAccess_method_prefixLibrary() {
     resolveTestUnit('''
 import 'dart:async' as pref;
 main(pref.Future f) {
   f.wait([]);
 }
 ''');
     assertHasFix(FixKind.CHANGE_TO_STATIC_ACCESS, '''
 import 'dart:async' as pref;
 main(pref.Future f) {
@@ skipping 14 matching lines @@
     assertHasFix(FixKind.CHANGE_TO_STATIC_ACCESS, '''
 class A {
   static get foo => 42;
 }
 main(A a) {
   A.foo;
 }
 ''');
   }
 
+  void test_changeToStaticAccess_property_importType() {
+    addSource('/libA.dart', r'''
+library libA;
+class A {
+  static get foo => null;
+}
+''');
+    addSource('/libB.dart', r'''
+library libB;
+import 'libA.dart';
+class B extends A {}
+''');
+    resolveTestUnit('''
+import 'libB.dart';
+main(B b) {
+  b.foo;
+}
+''');
+    assertHasFix(FixKind.CHANGE_TO_STATIC_ACCESS, '''
+import 'libB.dart';
+import 'libA.dart';
+main(B b) {
+  A.foo;
+}
+''');
+  }
+
   void test_createClass() {
     resolveTestUnit('''
 main() {
   Test v = null;
 }
 ''');
     assertHasFix(FixKind.CREATE_CLASS, '''
 main() {
   Test v = null;
 }
@@ skipping 169 matching lines @@
 class B extends A {
   int existingField;
 
   B(int field) : super(field);
 
   void existingMethod() {}
 }
 ''');
   }
 
+  void test_createConstructorSuperImplicit_importType() {
+    addSource('/libA.dart', r'''
+library libA;
+class A {}
+''');
+    addSource('/libB.dart', r'''
+library libB;
+import 'libA.dart';
+class B {
+  B(A a);
+}
+''');
+    resolveTestUnit('''
+import 'libB.dart';
+class C extends B {
+}
+''');
+    assertHasFix(FixKind.CREATE_CONSTRUCTOR_SUPER, '''
+import 'libB.dart';
+import 'libA.dart';
+class C extends B {
+  C(A a) : super(a);
+}
+''');
+  }
+
   void test_createConstructorSuperImplicit_named() {
     resolveTestUnit('''
 class A {
   A.named(p1, int p2);
 }
 class B extends A {
   int existingField;
 
   void existingMethod() {}
 }
@@ skipping 156 matching lines @@
 class A {
   var test;
 
   main() {
     test;
   }
 }
 ''');
   }
 
+  void test_createField_importType() {
+    addSource('/libA.dart', r'''
+library libA;
+class A {}
+''');
+    addSource('/libB.dart', r'''
+library libB;
+import 'libA.dart';
+A getA() => null;
+''');
+    resolveTestUnit('''
+import 'libB.dart';
+class C {
+}
+main(C c) {
+  c.test = getA();
+}
+''');
+    assertHasFix(FixKind.CREATE_FIELD, '''
+import 'libB.dart';
+import 'libA.dart';
+class C {
+  A test;
+}
+main(C c) {
+  c.test = getA();
+}
+''');
+  }
+
   void test_createField_setter_generic_BAD() {
     resolveTestUnit('''
 class A {
 }
 class B<T> {
   List<T> items;
   main(A a) {
     a.test = items;
   }
 }
@@ skipping 873 matching lines @@
 main() {
   useFunction(g: test);
 }
 useFunction({int g(double a, String b)}) {}
 
 int test(double a, String b) {
 }
 ''');
   }
 
+  void test_creationFunction_forFunctionType_importType() {
+    addSource('/libA.dart', r'''
+library libA;
+class A {}
+''');
+    addSource('/libB.dart', r'''
+library libB;
+import 'libA.dart';
+useFunction(int g(A a)) {}
+''');
+    resolveTestUnit('''
+import 'libB.dart';
+main() {
+  useFunction(test);
+}
+''');
+    assertHasFix(FixKind.CREATE_FUNCTION, '''
+import 'libB.dart';
+import 'libA.dart';
+main() {
+  useFunction(test);
+}
+
+int test(A a) {
+}
+''');
+  }
+
   void test_creationFunction_forFunctionType_method_enclosingClass_static() {
     resolveTestUnit('''
 class A {
   static foo() {
     useFunction(test);
   }
 }
 useFunction(int g(double a, String b)) {}
 ''');
     assertHasFix(FixKind.CREATE_METHOD, '''
@@ skipping 791 matching lines @@
   main() {
     process(items);
   }
 }
 
 void process(List<int> items) {
 }
 ''');
   }
 
+  void test_undefinedFunction_create_importType() {
+    addSource('/lib.dart', r'''
+library lib;
+import 'dart:async';
+Future getFuture() => null;
+''');
+    resolveTestUnit('''
+import 'lib.dart';
+main() {
+  test(getFuture());
+}
+''');
+    assertHasFix(FixKind.CREATE_FUNCTION, '''
+import 'lib.dart';
+import 'dart:async';
+main() {
+  test(getFuture());
+}
+
+void test(Future future) {
+}
+''');
+  }
+
   void test_undefinedFunction_create_nullArgument() {
     resolveTestUnit('''
 main() {
   test(null);
 }
 ''');
     assertHasFix(FixKind.CREATE_FUNCTION, '''
 main() {
   test(null);
 }
@@ skipping 607 matching lines @@
 
   List<Position> _findResultPositions(List<String> searchStrings) {
     List<Position> positions = <Position>[];
     for (String search in searchStrings) {
       int offset = resultCode.indexOf(search);
       positions.add(new Position(testFile, offset));
     }
     return positions;
   }
 }