Revert changes 17962-3 which break Dartium Debug build.

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/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 80 matching lines @@
 static void CollectFinalizedSuperClasses(
     const GrowableObjectArray& pending_classes,
     GrowableArray<intptr_t>* finalized_super_classes) {
   Class& cls = Class::Handle();
   Type& super_type = Type::Handle();
   for (intptr_t i = 0; i < pending_classes.Length(); i++) {
     cls ^= pending_classes.At(i);
     ASSERT(!cls.is_finalized());
     super_type ^= cls.super_type();
     if (!super_type.IsNull()) {
-      if (!super_type.IsMalformed() &&
-          super_type.HasResolvedTypeClass() &&
+      if (super_type.HasResolvedTypeClass() &&
           Class::Handle(super_type.type_class()).is_finalized()) {
         AddSuperType(super_type, finalized_super_classes);
       }
     }
   }
 }
 
 
 // Class finalization occurs:
 // a) when bootstrap process completes (VerifyBootstrapClasses).
@@ skipping 357 matching lines @@
 
     // Lookup the type class.
     const UnresolvedClass& unresolved_class =
         UnresolvedClass::Handle(type.unresolved_class());
     const Class& type_class =
         Class::Handle(ResolveClass(cls, unresolved_class));
 
     // Replace unresolved class with resolved type class.
     const Type& parameterized_type = Type::Cast(type);
     if (!type_class.IsNull()) {
-      parameterized_type.set_type_class(type_class);
+      parameterized_type.set_type_class(Object::Handle(type_class.raw()));
     } else {
       // The type class could not be resolved. The type is malformed.
       FinalizeMalformedType(Error::Handle(),  // No previous error.
                             cls, parameterized_type, finalization,
                             "cannot resolve class name '%s' from '%s'",
                             String::Handle(unresolved_class.Name()).ToCString(),
                             String::Handle(cls.Name()).ToCString());
       return;
     }
   }
@@ skipping 238 matching lines @@
       AbstractType& type_arg = AbstractType::Handle(Type::DynamicType());
       for (intptr_t i = 0; i < num_type_parameters; i++) {
         // If no type parameters were provided, a raw type is desired, so we
         // create a vector of DynamicType.
         if (!arguments.IsNull()) {
           type_arg = arguments.TypeAt(i);
         }
         ASSERT(type_arg.IsFinalized());  // Index of type parameter is adjusted.
         full_arguments.SetTypeAt(offset + i, type_arg);
       }
-      // If the type class is a signature class, the full argument vector
-      // must include the argument vector of the super type.
-      // If the signature class is a function type alias, it is also the owner
-      // of its signature function and no super type is involved.
-      // If the signature class is canonical (not an alias), the owner of its
-      // signature function may either be an alias or the enclosing class of a
-      // local function, in which case the super type of the enclosing class is
-      // also considered when filling up the argument vector.
       if (type_class.IsSignatureClass()) {
         const Function& signature_fun =
             Function::Handle(type_class.signature_function());
         ASSERT(!signature_fun.is_static());
         const Class& sig_fun_owner = Class::Handle(signature_fun.Owner());
         FinalizeTypeArguments(sig_fun_owner, full_arguments, finalization);
       } else {
         FinalizeTypeArguments(type_class, full_arguments, finalization);
       }
       if (full_arguments.IsRaw(num_type_arguments)) {
@@ skipping 47 matching lines @@
       return parameterized_type.raw();
     }
   }
 
   // If the type class is a signature class, we are currently finalizing a
   // signature type, i.e. finalizing the result type and parameter types of the
   // signature function of this signature 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.
   if (type_class.IsSignatureClass()) {
-    // The class may be created while parsing a function body, after all
-    // pending classes have already been finalized.
-    FinalizeClass(type_class);
+    // Signature classes are finalized upon creation, except function type
+    // aliases.
+    if (type_class.IsCanonicalSignatureClass()) {
+      ASSERT(type_class.is_finalized());
+      // Resolve and finalize the result and parameter types of the signature
+      // function of this signature class.
+      ASSERT(type_class.SignatureType() == type.raw());
+      ResolveAndFinalizeSignature(
+          type_class, Function::Handle(type_class.signature_function()));
+    } else {
+      // This type is a function type alias. Its class may need to be finalized
+      // and checked for illegal self reference.
+      FinalizeClass(type_class);
+      // Finalizing the signature function here (as in the canonical case above)
+      // would not mark the canonical signature type as finalized.
+      const Type& signature_type = Type::Handle(type_class.SignatureType());
+      FinalizeType(cls, signature_type, finalization);
+    }
   }
 
   if (finalization >= kCanonicalize) {
     return parameterized_type.Canonicalize();
   } else {
     return parameterized_type.raw();
   }
 }
 
 
@@ skipping 175 matching lines @@
     }
   }
   // Collect interfaces, super interfaces, and super classes of this class.
   const GrowableObjectArray& interfaces =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   CollectInterfaces(cls, interfaces);
   // Include superclasses in list of interfaces and super interfaces.
   super_class = cls.SuperClass();
   while (!super_class.IsNull()) {
     interfaces.Add(super_class);
-    CollectInterfaces(super_class, interfaces);
     super_class = super_class.SuperClass();
   }
   // Resolve function signatures and check for conflicts in super classes and
   // interfaces.
   array = cls.functions();
   Function& function = Function::Handle();
   Function& overridden_function = Function::Handle();
   intptr_t num_functions = array.Length();
   String& function_name = String::Handle();
   for (intptr_t i = 0; i < num_functions; i++) {
@@ skipping 95 matching lines @@
     FinalizeClass(super_class);
   }
   // Finalize type parameters before finalizing the super type.
   FinalizeTypeParameters(cls);
   // Finalize super type.
   Type& super_type = Type::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     super_type ^= FinalizeType(cls, super_type, kCanonicalizeWellFormed);
     cls.set_super_type(super_type);
   }
+  // Signature classes are finalized upon creation, except function type
+  // aliases.
   if (cls.IsSignatureClass()) {
+    ASSERT(!cls.IsCanonicalSignatureClass());
     // Check for illegal self references.
     GrowableArray<intptr_t> visited_aliases;
     if (!IsAliasCycleFree(cls, &visited_aliases)) {
       const String& name = String::Handle(cls.Name());
       const Script& script = Script::Handle(cls.script());
       ReportError(script, cls.token_pos(),
                   "typedef '%s' illegally refers to itself",
                   name.ToCString());
     }
     cls.Finalize();
     // Signature classes extend Object. No need to add this class to the direct
     // subclasses of Object.
     ASSERT(super_type.IsNull() || super_type.IsObjectType());
-
-    // Resolve and finalize the result and parameter types of the signature
-    // function of this signature class.
-    const Function& sig_function = Function::Handle(cls.signature_function());
-    ResolveAndFinalizeSignature(cls, sig_function);
-
-    // Resolve and finalize the signature type of this signature class.
-    const Type& sig_type = Type::Handle(cls.SignatureType());
-    FinalizeType(cls, sig_type, kCanonicalizeWellFormed);
     return;
   }
   // Finalize interface types (but not necessarily interface classes).
   Array& interface_types = Array::Handle(cls.interfaces());
   AbstractType& interface_type = AbstractType::Handle();
   for (intptr_t i = 0; i < interface_types.Length(); i++) {
     interface_type ^= interface_types.At(i);
     interface_type = FinalizeType(cls, interface_type, kCanonicalizeWellFormed);
     interface_types.SetAt(i, interface_type);
   }
@@ skipping 34 matching lines @@
   }
   // No cycles.
   return true;
 }
 
 
 // Returns false if the function type alias illegally refers to itself.
 bool ClassFinalizer::IsAliasCycleFree(const Class& cls,
                                       GrowableArray<intptr_t>* visited) {
   ASSERT(cls.IsSignatureClass());
+  ASSERT(!cls.IsCanonicalSignatureClass());
   ASSERT(!cls.is_finalized());
   ASSERT(visited != NULL);
   const intptr_t cls_index = cls.id();
   for (int i = 0; i < visited->length(); i++) {
     if ((*visited)[i] == cls_index) {
       // We have already visited alias 'cls'. We found a cycle.
       return false;
     }
   }
 
   // Visit the result type and parameter types of this signature type.
   visited->Add(cls.id());
   const Function& function = Function::Handle(cls.signature_function());
   // Check class of result type.
   AbstractType& type = AbstractType::Handle(function.result_type());
   ResolveType(cls, type, kCanonicalize);
   if (type.IsType() && !type.IsMalformed()) {
     const Class& type_class = Class::Handle(type.type_class());
     if (!type_class.is_finalized() &&
         type_class.IsSignatureClass() &&
-        !IsAliasCycleFree(type_class, visited)) {
-      return false;
+        !type_class.IsCanonicalSignatureClass()) {
+      if (!IsAliasCycleFree(type_class, visited)) {
+        return false;
+      }
     }
   }
   // Check classes of formal parameter types.
   const intptr_t num_parameters = function.NumParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = function.ParameterTypeAt(i);
     ResolveType(cls, type, kCanonicalize);
     if (type.IsType() && !type.IsMalformed()) {
       const Class& type_class = Class::Handle(type.type_class());
       if (!type_class.is_finalized() &&
           type_class.IsSignatureClass() &&
-          !IsAliasCycleFree(type_class, visited)) {
-        return false;
+          !type_class.IsCanonicalSignatureClass()) {
+        if (!IsAliasCycleFree(type_class, visited)) {
+          return false;
+        }
       }
     }
   }
   visited->RemoveLast();
   return true;
 }
 
 
 // Recursively walks the graph of explicitly declared super type and
 // interfaces, resolving unresolved super types and interfaces.
@@ skipping 250 matching lines @@
     if ((finalization == kCanonicalizeWellFormed) ||
         FLAG_error_on_malformed_type) {
       ReportError(error);
     }
   }
   if (FLAG_enable_type_checks || !type.HasResolvedTypeClass()) {
     // In check mode, always mark the type as malformed.
     // In production mode, mark the type as malformed only if its type class is
     // not resolved.
     type.set_malformed_error(error);
-    if (!type.HasResolvedTypeClass()) {
-      // We do not want an unresolved class to end up in a snapshot.
-      type.set_type_class(Object::Handle(Object::null_class()));
-    }
   } else {
      // In production mode, do not mark the type with a resolved type class as
      // malformed, but make it raw.
+    ASSERT(type.HasResolvedTypeClass());
     type.set_arguments(AbstractTypeArguments::Handle());
   }
-  ASSERT(type.HasResolvedTypeClass());
   if (!type.IsFinalized()) {
     type.set_is_finalized_instantiated();
     // Do not canonicalize malformed types, since they may not be resolved.
   } else {
     // The only case where the malformed type was already finalized is when its
     // type arguments are not within bounds. In that case, we have a prev_error.
     ASSERT(!prev_error.IsNull());
   }
 }
 
@@ skipping 52 matching lines @@
 void ClassFinalizer::ReportError(const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
       Parser::FormatError(Script::Handle(), -1, "Error", format, args));
   va_end(args);
   ReportError(error);
 }
 
 }  // namespace dart