Use READY_RESOLVED_UNIT flag for ordering tasks.

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 analyzer.test.src.task.dart_test;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/dart/element/element.dart';
@@ skipping 3393 matching lines @@
       '/main.dart': '''
           import "a.dart";
 
           test1() {
             int x = 0;
             x = new A().a2;
           }
     '''
     });
     DartType dynamicType = context.typeProvider.dynamicType;
+    DartType intType = context.typeProvider.intType;
 
     computeResult(
         new LibrarySpecificUnit(sources[0], sources[0]), RESOLVED_UNIT8);
     CompilationUnit unit0 = outputs[RESOLVED_UNIT8];
 
     // A.a2 should now be resolved on the rhs, but not yet inferred.
     assertVariableDeclarationTypes(
         AstFinder.getFieldInClass(unit0, "A", "a2"), dynamicType, dynamicType);
 
     computeResult(
         new LibrarySpecificUnit(sources[2], sources[2]), RESOLVED_UNIT8);
 
     // A.a2 should now be fully resolved and inferred.
     assertVariableDeclarationTypes(
-        AstFinder.getFieldInClass(unit0, "A", "a2"), dynamicType, dynamicType);
+        AstFinder.getFieldInClass(unit0, "A", "a2"), dynamicType, intType);
   }
 
   // Test inference of instance fields across units with cycles
   void test_perform_inference_cross_unit_static_instance() {
     List<Source> sources = newSources({
       '/a.dart': '''
           import 'b.dart';
           class A {
             static final a1 = B.b1;
             final a2 = new B().b2;
@@ skipping 91 matching lines @@
 
     // B.b2 shoud be resolved on the rhs, but not yet inferred.
     assertVariableDeclarationTypes(
         AstFinder.getFieldInClass(unit0, "B", "b2"), dynamicType, intType);
 
     computeResult(
         new LibrarySpecificUnit(sources[1], sources[1]), RESOLVED_UNIT8);
 
     // A.a2 should now be fully resolved and inferred.
     assertVariableDeclarationTypes(
-        AstFinder.getFieldInClass(unit0, "A", "a2"), dynamicType, dynamicType);
+        AstFinder.getFieldInClass(unit0, "A", "a2"), dynamicType, intType);
 
     // B.b2 should now be fully resolved and inferred.
     assertVariableDeclarationTypes(
         AstFinder.getFieldInClass(unit0, "B", "b2"), intType, intType);
   }
 }
 
 @reflectiveTest
 class ResolveLibraryTaskTest extends _AbstractDartTaskTest {
   test_perform() {
@@ skipping 446 matching lines @@
 
     assertAssignmentStatementTypes(statements[1], intType, intType);
     assertAssignmentStatementTypes(statements[2], intType, intType);
     assertAssignmentStatementTypes(statements[3], intType, intType);
     assertAssignmentStatementTypes(statements[4], intType, intType);
   }
 
   // Test that local variables in method bodies are inferred appropriately
   void test_perform_inference_cross_unit_instance() {
     List<Source> sources = newSources({
+      '/b.dart': '''
+          class B {
+            final b2 = 1;
+          }
+      ''',
       '/a.dart': '''
           import 'b.dart';
           class A {
             final a2 = new B().b2;
           }
       ''',
-      '/b.dart': '''
-          class B {
-            final b2 = 1;
-          }
-      ''',
       '/main.dart': '''
           import "a.dart";
 
           test1() {
             int x = 0;
             x = new A().a2;
           }
     '''
     });
     List<dynamic> units =
         computeLibraryResults(sources, RESOLVED_UNIT10).toList();
     CompilationUnit unit0 = units[0];
     CompilationUnit unit1 = units[1];
     CompilationUnit unit2 = units[2];
 
     InterfaceType intType = context.typeProvider.intType;
 
     assertVariableDeclarationTypes(
-        AstFinder.getFieldInClass(unit0, "A", "a2"), intType, intType);
+        AstFinder.getFieldInClass(unit0, "B", "b2"), intType, intType);
 
     assertVariableDeclarationTypes(
-        AstFinder.getFieldInClass(unit1, "B", "b2"), intType, intType);
+        AstFinder.getFieldInClass(unit1, "A", "a2"), intType, intType);
 
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit2, "test1");
 
     assertAssignmentStatementTypes(statements[1], intType, intType);
   }
 
   // Test inference interactions between local variables and fields
   void test_perform_inference_cross_unit_instance_member() {
     List<Source> sources = newSources({
-      '/a.dart': '''
-          import 'b.dart';
-            var bar = new B();
-            void foo() {
-              String x = bar.f.z;
-            }
-      ''',
       '/b.dart': '''
         class C {
           var z = 3;
         }
 
         class B {
           var f = new C();
         }
       ''',
+      '/a.dart': '''
+          import 'b.dart';
+            var bar = new B();
+            void foo() {
+              String x = bar.f.z;
+            }
+      ''',
       '/c.dart': '''
           import 'b.dart';
             var bar = new B();
             void foo() {
               String x = bar.f.z;
             }
     '''
     });
     List<dynamic> units =
         computeLibraryResults(sources, RESOLVED_UNIT10).toList();
-    CompilationUnit unit0 = units[0];
+    CompilationUnit unit1 = units[1];
     CompilationUnit unit2 = units[2];
 
     InterfaceType intType = context.typeProvider.intType;
     InterfaceType stringType = context.typeProvider.stringType;
 
     assertVariableDeclarationStatementTypes(
-        AstFinder.getStatementsInTopLevelFunction(unit0, "foo")[0],
+        AstFinder.getStatementsInTopLevelFunction(unit1, "foo")[0],
         stringType,
         intType);
     assertVariableDeclarationStatementTypes(
         AstFinder.getStatementsInTopLevelFunction(unit2, "foo")[0],
         stringType,
         intType);
   }
 
   // Test inference interactions between local variables and top level
   // variables
@@ skipping 41 matching lines @@
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit2, "test1");
 
     assertAssignmentStatementTypes(statements[0], intType, stringType);
     assertAssignmentStatementTypes(statements[1], intType, stringType);
   }
 
   // Test that inference does not propagate from null
   void test_perform_inference_cross_unit_static_instance() {
     List<Source> sources = newSources({
+      '/b.dart': '''
+          class B {
+            static final b1 = 1;
+            final b2 = 1;
+          }
+      ''',
       '/a.dart': '''
           import 'b.dart';
           class A {
             static final a1 = B.b1;
             final a2 = new B().b2;
           }
       ''',
-      '/b.dart': '''
-          class B {
-            static final b1 = 1;
-            final b2 = 1;
-          }
-      ''',
       '/main.dart': '''
           import "a.dart";
 
           test1() {
             int x = 0;
             // inference in A now works.
             x = A.a1;
             x = new A().a2;
           }
     '''
     });
     List<dynamic> units =
         computeLibraryResults(sources, RESOLVED_UNIT10).toList();
     CompilationUnit unit0 = units[0];
     CompilationUnit unit1 = units[1];
     CompilationUnit unit2 = units[2];
 
     InterfaceType intType = context.typeProvider.intType;
 
     assertVariableDeclarationTypes(
-        AstFinder.getFieldInClass(unit0, "A", "a1"), intType, intType);
+        AstFinder.getFieldInClass(unit0, "B", "b1"), intType, intType);
     assertVariableDeclarationTypes(
-        AstFinder.getFieldInClass(unit0, "A", "a2"), intType, intType);
+        AstFinder.getFieldInClass(unit0, "B", "b2"), intType, intType);
 
     assertVariableDeclarationTypes(
-        AstFinder.getFieldInClass(unit1, "B", "b1"), intType, intType);
+        AstFinder.getFieldInClass(unit1, "A", "a1"), intType, intType);
     assertVariableDeclarationTypes(
-        AstFinder.getFieldInClass(unit1, "B", "b2"), intType, intType);
+        AstFinder.getFieldInClass(unit1, "A", "a2"), intType, intType);
 
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit2, "test1");
 
     assertAssignmentStatementTypes(statements[1], intType, intType);
     assertAssignmentStatementTypes(statements[2], intType, intType);
   }
 
   // Test inference across units (non-cyclic)
   void test_perform_inference_local_variables() {
@@ skipping 458 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);
   }
 }