Fix delayed resolution of function result types (fixes #27760).

runtime/vm/parser.cc

 // Copyright (c) 2012, 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.
 
 #include "vm/parser.h"
 #include "vm/flags.h"
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 #include "lib/invocation_mirror.h"
@@ skipping 2053 matching lines @@
 
       // Finish parsing the function type parameter.
       if (CurrentToken() == Token::kLT) {
         if (!FLAG_generic_method_syntax) {
           ReportError("generic function types not supported");
         }
         ParseTypeParameters(false);  // Not parameterizing class, but function.
       }
 
       // 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;
 
       // Add implicit closure object parameter.
       func_params.AddFinalParameter(TokenPos(), &Symbols::ClosureParameter(),
                                     &Object::dynamic_type());
 
       const bool no_explicit_default_values = false;
       ParseFormalParameterList(no_explicit_default_values, false, &func_params);
@@ skipping 16 matching lines @@
       // A signature type itself cannot be malformed or malbounded, only its
       // signature function's result type or parameter types may be.
       ASSERT(!signature_type.IsMalformed());
       ASSERT(!signature_type.IsMalbounded());
       // The type of the parameter is now the signature type.
       parameter.type = &signature_type;
     }
   } 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;
     }
   }
 
   if ((CurrentToken() == Token::kASSIGN) || (CurrentToken() == Token::kCOLON)) {
     if ((!params->has_optional_positional_parameters &&
          !params->has_optional_named_parameters) ||
         !allow_explicit_default_value) {
       ReportError("parameter must not specify a default value");
@@ skipping 5540 matching lines @@
     if (!found_func) {
       ParseTypeParameters(false);  // Not parameterizing class, but function.
     } else {
       TryParseTypeParameters();
     }
   }
 
   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);
   }
 
   CheckToken(Token::kLPAREN);
 
   // The function type needs to be finalized at compile time, since the closure
   // may be type checked at run time when assigned to a function variable,
   // passed as a function argument, or returned as a function result.
@@ skipping 4223 matching lines @@
               "type parameter '%s' cannot be parameterized",
               String::Handle(Z, type_parameter.name()).ToCString());
           return;
         }
         *type = type_parameter.raw();
         return;
       }
       // 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);
       }
     } else {
       // Resolve class name in the scope of the library prefix.
       const Object& prefix =
           Object::Handle(Z, unresolved_class.library_or_library_prefix());
       ASSERT(prefix.IsLibraryPrefix());
       resolved_type_class =
           LibraryPrefix::Cast(prefix).LookupClass(unresolved_class_name);
@@ skipping 2575 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME