commit 9080ec05a4485b88679af7df2a0f2f4a9c8bf403
author Regis Crelier <regis@google.com> Fri Dec 02 15:22:01 2016 -0800
committer William Hesse <whesse@google.com> Mon Dec 05 11:32:02 2016 +0100
tree fa9a9ba658b224d2d5f6cd8698e08a4983252dc8
parent efec09025752044af0c20f63a802bcfd7a933759

Fix delayed resolution of function result types (fixes #27760).
Resolution is delayed to properly handle generic results of generic functions.
Resolution has to be done in the library declaring the function and not in the
library declaring a mixin application mixing in the function.

R=hausner@google.com

Review URL: https://codereview.chromium.org/2549443005 .

runtime/vm/parser.cc

diff --git a/runtime/vm/parser.cc b/runtime/vm/parser.cc
index f9fd601..1a91fcb 100644
--- a/runtime/vm/parser.cc
+++ b/runtime/vm/parser.cc
@@ -2071,7 +2071,9 @@
       }
 
       // Now that type parameters are declared, the result type can be resolved.
-      ResolveType(ClassFinalizer::kResolveTypeParameters, &result_type);
+      ResolveType(is_top_level_ ? ClassFinalizer::kResolveTypeParameters
+                                : ClassFinalizer::kCanonicalize,
+                  &result_type);
 
       ASSERT(CurrentToken() == Token::kLPAREN);
       ParamList func_params;
@@ -2108,11 +2110,12 @@
   } else {
     if (!parameter.type->IsFinalized()) {
       AbstractType& type = AbstractType::ZoneHandle(Z, parameter.type->raw());
-      ResolveType(ClassFinalizer::kResolveTypeParameters, &type);
-      if (!is_top_level_) {
-        type = ClassFinalizer::FinalizeType(
-            Class::Handle(Z, innermost_function().origin()), type,
-            ClassFinalizer::kCanonicalize);
+      if (is_top_level_) {
+        ResolveType(ClassFinalizer::kResolveTypeParameters, &type);
+      } else {
+        ResolveType(ClassFinalizer::kCanonicalize, &type);
+        type = ClassFinalizer::FinalizeType(current_class(), type,
+                                            ClassFinalizer::kCanonicalize);
       }
       parameter.type = &type;
     }
@@ -7673,7 +7676,7 @@
   if (!found_func && !result_type.IsFinalized()) {
     // Now that type parameters are declared, the result type can be resolved
     // and finalized.
-    ResolveType(ClassFinalizer::kResolveTypeParameters, &result_type);
+    ResolveType(ClassFinalizer::kCanonicalize, &result_type);
     result_type = ClassFinalizer::FinalizeType(current_class(), result_type,
                                                ClassFinalizer::kCanonicalize);
     function.set_result_type(result_type);
@@ -11917,6 +11920,8 @@
       // The referenced class may not have been parsed yet. It would be wrong
       // to resolve it too early to an imported class of the same name. Only
       // resolve the class when a finalized type is requested.
+      // Note that when compiling a cloned mixin function, library_ may be
+      // different than current_class's library.
       if (finalization > ClassFinalizer::kResolveTypeParameters) {
         resolved_type_class = library_.LookupClass(unresolved_class_name);
       }