Resolve signature from correct scope class (fix #25609).

runtime/vm/class_finalizer.cc

 // Copyright (c) 2013, 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/class_finalizer.h"
 
 #include "vm/code_generator.h"
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
@@ skipping 508 matching lines @@
   if (type.IsType()) {
     resolved_type = ResolveTypeClass(cls, Type::Cast(type));
     if (resolved_type.IsMalformed()) {
       ASSERT(resolved_type.IsResolved());
       return resolved_type.raw();
     }
   } else {
     ASSERT(type.IsFunctionType());
     const Function& signature =
         Function::Handle(FunctionType::Cast(type).signature());
-    ResolveSignature(cls, signature);
+    const Class& scope_class =
+        Class::Handle(FunctionType::Cast(type).scope_class());
+    if (scope_class.IsTypedefClass()) {
+      ResolveSignature(scope_class, signature);
+    } else {
+      ResolveSignature(cls, signature);
+    }
     resolved_type = type.raw();
   }
   // Mark type as resolved before resolving its type arguments in order to avoid
   // repeating resolution of recursive types.
   resolved_type.SetIsResolved();
   // Resolve type arguments, if any.
   const TypeArguments& arguments =
       TypeArguments::Handle(resolved_type.arguments());
   if (!arguments.IsNull()) {
     const intptr_t num_arguments = arguments.Length();
@@ skipping 609 matching lines @@
   // If the type is a FunctionType, we also need to finalize the types in its
   // signature, i.e. finalize the result type and parameter types of the
   // signature function of this function type.
   // We do this after marking this type as finalized in order to allow a
   // function type to refer to itself via its parameter types and result type.
   // Note that we do not instantiate these types according to the type
   // arguments. This will happen on demand when executing a type test.
   if (resolved_type.IsFunctionType()) {
     const Function& signature =
         Function::Handle(Z, FunctionType::Cast(resolved_type).signature());
-    FinalizeSignature(cls, signature);
+    const Class& scope_class =
+        Class::Handle(Z, FunctionType::Cast(resolved_type).scope_class());
+    if (scope_class.IsTypedefClass()) {
+      FinalizeSignature(scope_class, signature);
+    } else {
+      FinalizeSignature(cls, signature);
+    }
   }
 
   if (FLAG_trace_type_finalization) {
     THR_Print("Done finalizing type '%s' with %" Pd " type args: %s\n",
               String::Handle(Z, resolved_type.Name()).ToCString(),
               num_expanded_type_arguments,
               resolved_type.ToCString());
   }
 
   if (finalization >= kCanonicalize) {
@@ skipping 2101 matching lines @@
   ASSERT(fields_array.Length() == ByteBuffer::NumberOfFields());
   field ^= fields_array.At(0);
   ASSERT(field.Offset() == ByteBuffer::data_offset());
   name ^= field.name();
   expected_name ^= String::New("_data");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
 #endif
 }
 
 }  // namespace dart