Ensure types are resolved for combined import/export closures.

pkg/analyzer/test/src/task/dart_test.dart

 // Copyright (c) 2015, 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.src.task.dart_test;
 
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 1163 matching lines @@
     // d.dart
     {
       _computeResult(sourceD, IMPORT_SOURCE_CLOSURE);
       expect(task, new isInstanceOf<BuildSourceClosuresTask>());
       List<Source> closure = outputs[IMPORT_SOURCE_CLOSURE];
       expect(closure, contains(sourceD));
       expect(closure, contains(coreSource));
     }
   }
 
+  test_perform_importExportClosure() {
+    Source sourceA = newSource('/a.dart', '''
+library lib_a;
+''');
+    Source sourceB = newSource('/b.dart', '''
+library lib_b;
+export 'a.dart';
+''');
+    Source sourceC = newSource('/c.dart', '''
+library lib_c;
+import 'b.dart';
+''');
+    Source coreSource = context.sourceFactory.resolveUri(null, 'dart:core');
+    // c.dart
+    {
+      _computeResult(sourceC, IMPORT_EXPORT_SOURCE_CLOSURE);
+      expect(task, new isInstanceOf<BuildSourceClosuresTask>());
+      List<Source> closure = outputs[IMPORT_EXPORT_SOURCE_CLOSURE];
+      expect(closure, contains(sourceA));
+      expect(closure, contains(sourceB));
+      expect(closure, contains(sourceC));
+      expect(closure, contains(coreSource));
+    }
+    // b.dart
+    {
+      _computeResult(sourceB, IMPORT_EXPORT_SOURCE_CLOSURE);
+      expect(task, new isInstanceOf<BuildSourceClosuresTask>());
+      List<Source> closure = outputs[IMPORT_EXPORT_SOURCE_CLOSURE];
+      expect(closure, contains(sourceA));
+      expect(closure, contains(sourceB));
+      expect(closure, contains(coreSource));
+    }
+  }
+
   test_perform_isClient_false() {
     Source sourceA = newSource('/a.dart', '''
 library lib_a;
 import 'b.dart';
 ''');
     newSource('/b.dart', '''
 library lib_b;
 ''');
     _computeResult(sourceA, IS_CLIENT);
     expect(task, new isInstanceOf<BuildSourceClosuresTask>());
@@ skipping 936 matching lines @@
     expect(outputs[EXPLICITLY_IMPORTED_LIBRARIES], hasLength(0));
     expect(outputs[EXPORTED_LIBRARIES], hasLength(0));
     _assertHasCore(outputs[IMPORTED_LIBRARIES], 1);
     expect(outputs[INCLUDED_PARTS], hasLength(0));
     expect(outputs[PARSE_ERRORS], hasLength(0));
     expect(outputs[PARSED_UNIT], isNotNull);
     expect(outputs[SOURCE_KIND], SourceKind.PART);
     expect(outputs[UNITS], hasLength(1));
   }
 
-  test_perform_computeSourceKind_noDirectives_noContainingLibraries() {
-    _performParseTask('');
-    expect(outputs[SOURCE_KIND], SourceKind.LIBRARY);
-  }
-
   test_perform_computeSourceKind_noDirectives_hasContainingLibraries() {
     // Parse "lib.dart" to let the context know that "test.dart" is a part.
     _computeResult(newSource('/lib.dart', r'''
 library lib;
 part 'test.dart';
 '''), PARSED_UNIT);
     // So, know "test.dat" is parsed as a part.
     _performParseTask('');
     expect(outputs[SOURCE_KIND], SourceKind.PART);
   }
 
+  test_perform_computeSourceKind_noDirectives_noContainingLibraries() {
+    _performParseTask('');
+    expect(outputs[SOURCE_KIND], SourceKind.LIBRARY);
+  }
+
   test_perform_doesNotExist() {
     _performParseTask(null);
     expect(outputs, hasLength(8));
     expect(outputs[EXPLICITLY_IMPORTED_LIBRARIES], hasLength(0));
     expect(outputs[EXPORTED_LIBRARIES], hasLength(0));
     _assertHasCore(outputs[IMPORTED_LIBRARIES], 1);
     expect(outputs[INCLUDED_PARTS], hasLength(0));
     expect(outputs[PARSE_ERRORS], hasLength(0));
     expect(outputs[PARSED_UNIT], isNotNull);
     expect(outputs[SOURCE_KIND], SourceKind.UNKNOWN);
@@ skipping 153 matching lines @@
 }
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     _computeResult(target, RESOLVED_UNIT6);
     expect(task, new isInstanceOf<ResolveReferencesTask>());
     // validate
     _fillErrorListener(RESOLVE_REFERENCES_ERRORS);
     errorListener.assertErrorsWithCodes(
         <ErrorCode>[StaticTypeWarningCode.UNDEFINED_METHOD]);
   }
+
+  test_perform_importExport() {
+    newSource('/a.dart', '''
+library a;
+class A<T> {
+  T m() {}
+}
+''');
+    newSource('/b.dart', '''
+library b;
+export 'a.dart';
+''');
+    Source sourceC = newSource('/c.dart', '''
+library c;
+import 'b.dart';
+main() {
+  new A<int>().m();
+}
+''');
+    _computeResult(new LibrarySpecificUnit(sourceC, sourceC), RESOLVED_UNIT6);
+    expect(task, new isInstanceOf<ResolveReferencesTask>());
+    // validate
+    CompilationUnit unit = outputs[RESOLVED_UNIT6];
+    expect(unit, isNotNull);
+    {
+      FunctionDeclaration functionDeclaration = unit.declarations[0];
+      BlockFunctionBody body = functionDeclaration.functionExpression.body;
+      List<Statement> statements = body.block.statements;
+      ExpressionStatement statement = statements[0];
+      MethodInvocation invocation = statement.expression;
+      MethodElement methodElement = invocation.methodName.staticElement;
+      expect(methodElement, isNotNull);
+      expect(methodElement.type, isNotNull);
+      expect(methodElement.returnType.toString(), 'int');
+    }
+  }
 }
 
 @reflectiveTest
 class ResolveUnitTypeNamesTaskTest extends _AbstractDartTaskTest {
   test_perform() {
     Source source = newSource('/test.dart', '''
 class A {}
 class B extends A {}
 int f(String p) => p.length;
 ''');
@@ skipping 225 matching lines @@
   /**
    * Fill [errorListener] with [result] errors in the current [task].
    */
   void _fillErrorListener(ResultDescriptor<List<AnalysisError>> result) {
     List<AnalysisError> errors = task.outputs[result];
     expect(errors, isNotNull, reason: result.name);
     errorListener = new GatheringErrorListener();
     errorListener.addAll(errors);
   }
 }