Fix typedef cycle check (fixes #25620).

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 2552 matching lines @@
                                         const AbstractType& type,
                                         GrowableArray<intptr_t>* visited) {
   ASSERT(visited != NULL);
   AbstractType& resolved_type = AbstractType::Handle(ResolveType(cls, type));
   bool checking_typedef = false;
   if ((resolved_type.IsType() || resolved_type.IsFunctionType()) &&
       !resolved_type.IsMalformed()) {
     AbstractType& other_type = AbstractType::Handle();
     if (resolved_type.IsFunctionType()) {
       const Class& scope_class = Class::Handle(resolved_type.type_class());
-      if (!scope_class.is_type_finalized() && scope_class.IsTypedefClass()) {
+      const Function& signature_function =
+          Function::Handle(FunctionType::Cast(resolved_type).signature());
+      // The signature function of this function type may be a local signature
+      // function used in a formal parameter type of the typedef signature, but
+      // not the typedef signature function itself, thus not qualifying as an
+      // illegal self reference.
+      if (!scope_class.is_type_finalized() &&
+          scope_class.IsTypedefClass() &&
+          (scope_class.signature_function() == signature_function.raw())) {
         checking_typedef = true;
         const intptr_t scope_class_id = scope_class.id();
         ASSERT(visited != NULL);
         for (intptr_t i = 0; i < visited->length(); i++) {
           if ((*visited)[i] == scope_class_id) {
             // We have already visited alias 'scope_class'. We found a cycle.
             return false;
           }
         }
         visited->Add(scope_class_id);
       }
       // Check the bounds of this function type.
       const intptr_t num_type_params = scope_class.NumTypeParameters();
       TypeParameter& type_param = TypeParameter::Handle();
       const TypeArguments& type_params =
           TypeArguments::Handle(scope_class.type_parameters());
       ASSERT((type_params.IsNull() && (num_type_params == 0)) ||
              (type_params.Length() == num_type_params));
       for (intptr_t i = 0; i < num_type_params; i++) {
         type_param ^= type_params.TypeAt(i);
         other_type = type_param.bound();
         if (!IsTypedefCycleFree(cls, other_type, visited)) {
           return false;
         }
       }
       // Check the result type of the signature of this function type.
-      const Function& function =
-          Function::Handle(FunctionType::Cast(resolved_type).signature());
-      other_type = function.result_type();
+      other_type = signature_function.result_type();
       if (!IsTypedefCycleFree(cls, other_type, visited)) {
         return false;
       }
       // Check the parameter types of the signature of this function type.
-      const intptr_t num_parameters = function.NumParameters();
+      const intptr_t num_parameters = signature_function.NumParameters();
       for (intptr_t i = 0; i < num_parameters; i++) {
-        other_type = function.ParameterTypeAt(i);
+        other_type = signature_function.ParameterTypeAt(i);
         if (!IsTypedefCycleFree(cls, other_type, visited)) {
           return false;
         }
       }
     }
     const TypeArguments& type_args =
         TypeArguments::Handle(resolved_type.arguments());
     if (!type_args.IsNull()) {
       for (intptr_t i = 0; i < type_args.Length(); i++) {
         other_type = type_args.TypeAt(i);
@@ skipping 668 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