Migrate logging infrastructure Isolate->Thread

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 320 matching lines @@
     ASSERT(target.IsNull());
     return;
   }
   if (!target.IsNull()) {
     // Already resolved.
     return;
   }
 
   // Target is not resolved yet.
   if (FLAG_trace_class_finalization) {
-    ISL_Print("Resolving redirecting factory: %s\n",
+    THR_Print("Resolving redirecting factory: %s\n",
               String::Handle(factory.name()).ToCString());
   }
   type ^= FinalizeType(cls, type, kCanonicalize);
   factory.SetRedirectionType(type);
   if (type.IsMalformedOrMalbounded()) {
     ASSERT(factory.RedirectionTarget() == Function::null());
     return;
   }
   ASSERT(!type.IsTypeParameter());  // Resolved in parser.
   if (type.IsDynamicType()) {
@@ skipping 101 matching lines @@
   factory.SetRedirectionTarget(target_target);
 }
 
 
 void ClassFinalizer::ResolveTypeClass(const Class& cls,
                                       const AbstractType& type) {
   if (type.IsFinalized() || type.HasResolvedTypeClass()) {
     return;
   }
   if (FLAG_trace_type_finalization) {
-    ISL_Print("Resolve type class of '%s'\n",
+    THR_Print("Resolve type class of '%s'\n",
               String::Handle(type.Name()).ToCString());
   }
 
   // Type parameters are always resolved in the parser in the correct
   // non-static scope or factory scope. That resolution scope is unknown here.
   // Being able to resolve a type parameter from class cls here would indicate
   // that the type parameter appeared in a static scope. Leaving the type as
   // unresolved is the correct thing to do.
 
   // Lookup the type class.
@@ skipping 18 matching lines @@
   parameterized_type.set_type_class(type_class);
 }
 
 
 void ClassFinalizer::ResolveType(const Class& cls, const AbstractType& type) {
   if (type.IsResolved()) {
     return;
   }
   ASSERT(type.IsType());
   if (FLAG_trace_type_finalization) {
-    ISL_Print("Resolve type '%s'\n", String::Handle(type.Name()).ToCString());
+    THR_Print("Resolve type '%s'\n", String::Handle(type.Name()).ToCString());
   }
   ResolveTypeClass(cls, type);
   if (type.IsMalformed()) {
     ASSERT(type.IsResolved());
     return;
   }
   // Mark type as resolved before resolving its type arguments in order to avoid
   // repeating resolution of recursive types.
   Type::Cast(type).set_is_resolved();
   // Resolve type arguments, if any.
   const TypeArguments& arguments = TypeArguments::Handle(type.arguments());
   if (!arguments.IsNull()) {
     const intptr_t num_arguments = arguments.Length();
     AbstractType& type_argument = AbstractType::Handle();
     for (intptr_t i = 0; i < num_arguments; i++) {
       type_argument = arguments.TypeAt(i);
       ResolveType(cls, type_argument);
     }
   }
 }
 
 
 void ClassFinalizer::FinalizeTypeParameters(
     const Class& cls,
     PendingTypes* pending_types) {
   if (FLAG_trace_type_finalization) {
-    ISL_Print("Finalizing type parameters of '%s'\n",
+    THR_Print("Finalizing type parameters of '%s'\n",
               String::Handle(cls.Name()).ToCString());
   }
   if (cls.IsMixinApplication()) {
     // Setup the type parameters of the mixin application and finalize the
     // mixin type.
     ApplyMixinType(cls, pending_types);
   }
   // The type parameter bounds are not finalized here.
   const TypeArguments& type_parameters =
       TypeArguments::Handle(cls.type_parameters());
@@ skipping 18 matching lines @@
 // The Dart Language Specification does not disallow the declaration and use of
 // non-contractive types (this may change). They are nevertheless disallowed
 // as an implementation restriction in the VM since they cause divergence.
 // A non-contractive type can be detected by looking at the queue of types
 // pending finalization that are mutually recursive with the checked type.
 void ClassFinalizer::CheckRecursiveType(const Class& cls,
                                         const Type& type,
                                         PendingTypes* pending_types) {
   Isolate* isolate = Isolate::Current();
   if (FLAG_trace_type_finalization) {
-    ISL_Print("Checking recursive type '%s': %s\n",
+    THR_Print("Checking recursive type '%s': %s\n",
               String::Handle(type.Name()).ToCString(),
               type.ToCString());
   }
   const Class& type_cls = Class::Handle(isolate, type.type_class());
   const TypeArguments& arguments =
       TypeArguments::Handle(isolate, type.arguments());
   // A type can only be recursive via its type arguments.
   ASSERT(!arguments.IsNull());
   const intptr_t num_type_args = arguments.Length();
   ASSERT(num_type_args > 0);
   ASSERT(num_type_args == type_cls.NumTypeArguments());
   const intptr_t num_type_params = type_cls.NumTypeParameters();
   const intptr_t first_type_param = num_type_args - num_type_params;
   // If the type is not generic (num_type_params == 0) or if its type parameters
   // are instantiated, no divergence can occur. Note that if the type parameters
   // are null, i.e. if the generic type is raw, they are considered
   // instantiated and no divergence can occur.
   if ((num_type_params == 0) ||
       arguments.IsSubvectorInstantiated(first_type_param, num_type_params)) {
     return;
   }
   // The type parameters are not instantiated. Verify that there is no other
   // type pending finalization with the same type class, but different
   // uninstantiated type parameters.
   TypeArguments& pending_arguments = TypeArguments::Handle(isolate);
   const intptr_t num_pending_types = pending_types->length();
   for (intptr_t i = num_pending_types - 1; i >= 0; i--) {
     const Type& pending_type = Type::Cast(pending_types->At(i));
     if (FLAG_trace_type_finalization) {
-      ISL_Print("  Comparing with pending type '%s': %s\n",
+      THR_Print("  Comparing with pending type '%s': %s\n",
                 String::Handle(pending_type.Name()).ToCString(),
                 pending_type.ToCString());
     }
     if ((pending_type.raw() != type.raw()) &&
         (pending_type.type_class() == type_cls.raw())) {
       pending_arguments = pending_type.arguments();
       if (!pending_arguments.IsSubvectorEquivalent(arguments,
                                                    first_type_param,
                                                    num_type_params) &&
           !pending_arguments.IsSubvectorInstantiated(first_type_param,
@@ skipping 71 matching lines @@
     const intptr_t super_offset = num_super_type_args - num_super_type_params;
     AbstractType& super_type_arg = AbstractType::Handle(Type::DynamicType());
     for (intptr_t i = super_offset; i < num_uninitialized_arguments; i++) {
       if (!super_type_args.IsNull()) {
         super_type_arg = super_type_args.TypeAt(i);
         if (!super_type_arg.IsTypeRef()) {
           if (super_type_arg.IsBeingFinalized()) {
             ASSERT(super_type_arg.IsType());
             CheckRecursiveType(cls, Type::Cast(super_type_arg), pending_types);
             if (FLAG_trace_type_finalization) {
-              ISL_Print("Creating TypeRef '%s': '%s'\n",
+              THR_Print("Creating TypeRef '%s': '%s'\n",
                         String::Handle(super_type_arg.Name()).ToCString(),
                         super_type_arg.ToCString());
             }
             super_type_arg = TypeRef::New(super_type_arg);
             super_type_args.SetTypeAt(i, super_type_arg);
           } else {
             if (!super_type_arg.IsFinalized()) {
               super_type_arg ^= FinalizeType(
                   cls, super_type_arg, kFinalize, pending_types);
               super_type_args.SetTypeAt(i, super_type_arg);
               // Note that super_type_arg may still not be finalized here, in
               // which case it is a TypeRef to a legal recursive type.
             }
           }
         }
         // Instantiate super_type_arg with the current argument vector.
         if (!super_type_arg.IsInstantiated()) {
           if (FLAG_trace_type_finalization && super_type_arg.IsTypeRef()) {
             AbstractType& ref_type = AbstractType::Handle(
                 TypeRef::Cast(super_type_arg).type());
-            ISL_Print("Instantiating TypeRef '%s': '%s'\n"
+            THR_Print("Instantiating TypeRef '%s': '%s'\n"
                       "  instantiator: '%s'\n",
                       String::Handle(super_type_arg.Name()).ToCString(),
                       ref_type.ToCString(),
                       arguments.ToCString());
           }
           Error& error = Error::Handle();
           super_type_arg = super_type_arg.InstantiateFrom(
               arguments, &error, trail, Heap::kOld);
           if (!error.IsNull()) {
             // InstantiateFrom does not report an error if the type is still
@@ skipping 166 matching lines @@
   // The bound error will be ignored in production mode.
   if (!bound_error.IsNull()) {
     // No compile-time error during finalization.
     const String& type_name = String::Handle(type.UserVisibleName());
     FinalizeMalboundedType(bound_error,
                            Script::Handle(cls.script()),
                            type,
                            "type '%s' has an out of bound type argument",
                            type_name.ToCString());
     if (FLAG_trace_type_finalization) {
-      ISL_Print("Marking type '%s' as malbounded: %s\n",
+      THR_Print("Marking type '%s' as malbounded: %s\n",
                 String::Handle(type.Name()).ToCString(),
                 bound_error.ToCString());
     }
   }
 }
 
 
 RawAbstractType* ClassFinalizer::FinalizeType(
     const Class& cls,
     const AbstractType& type,
@@ skipping 24 matching lines @@
 
   // A malformed type gets mapped to a finalized type.
   ResolveType(cls, type);
   if (type.IsMalformed()) {
     ASSERT(type.IsFinalized());
     return type.raw();
   }
 
   Zone* Z = Thread::Current()->zone();
   if (FLAG_trace_type_finalization) {
-    ISL_Print("Finalizing type '%s' for class '%s'\n",
+    THR_Print("Finalizing type '%s' for class '%s'\n",
               String::Handle(Z, type.Name()).ToCString(),
               cls.ToCString());
   }
 
   if (type.IsTypeParameter()) {
     const TypeParameter& type_parameter = TypeParameter::Cast(type);
     const Class& parameterized_class =
         Class::Handle(Z, type_parameter.parameterized_class());
     ASSERT(!parameterized_class.IsNull());
     // The index must reflect the position of this type parameter in the type
     // arguments vector of its parameterized class. The offset to add is the
     // number of type arguments in the super type, which is equal to the
     // difference in number of type arguments and type parameters of the
     // parameterized class.
     const intptr_t offset = parameterized_class.NumTypeArguments() -
                             parameterized_class.NumTypeParameters();
     // Calling NumTypeParameters() may finalize this type parameter if it
     // belongs to a mixin application class.
     if (!type_parameter.IsFinalized()) {
       type_parameter.set_index(type_parameter.index() + offset);
       type_parameter.set_is_finalized();
     } else {
       ASSERT(cls.IsMixinApplication());
     }
 
     if (FLAG_trace_type_finalization) {
-      ISL_Print("Done finalizing type parameter '%s' with index %" Pd "\n",
+      THR_Print("Done finalizing type parameter '%s' with index %" Pd "\n",
                 String::Handle(Z, type_parameter.name()).ToCString(),
                 type_parameter.index());
     }
 
     // We do not canonicalize type parameters.
     return type_parameter.raw();
   }
 
   // At this point, we can only have a parameterized_type.
   const Type& parameterized_type = Type::Cast(type);
@@ skipping 134 matching lines @@
     parameterized_type.SetIsFinalized();
     // Do not yet remove the type from the pending_types array.
   }
 
   // If we are done finalizing a graph of mutually recursive types, check their
   // bounds.
   if (is_root_type) {
     for (intptr_t i = pending_types->length() - 1; i >= 0; i--) {
       CheckTypeBounds(cls, Type::Cast(pending_types->At(i)));
       if (FLAG_trace_type_finalization && type.IsRecursive()) {
-        ISL_Print("Done finalizing recursive type '%s': %s\n",
+        THR_Print("Done finalizing recursive type '%s': %s\n",
                   String::Handle(Z, type.Name()).ToCString(),
                   type.ToCString());
       }
     }
   }
 
   // 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.
     FinalizeTypesInClass(type_class);
   }
 
   if (FLAG_trace_type_finalization) {
-    ISL_Print("Done finalizing type '%s' with %" Pd " type args: %s\n",
+    THR_Print("Done finalizing type '%s' with %" Pd " type args: %s\n",
               String::Handle(Z, parameterized_type.Name()).ToCString(),
               parameterized_type.arguments() == TypeArguments::null() ?
                   0 : num_type_arguments,
               parameterized_type.ToCString());
   }
 
   if (finalization >= kCanonicalize) {
     if (FLAG_trace_type_finalization && parameterized_type.IsRecursive()) {
       AbstractType& type = Type::Handle(Z);
       type = parameterized_type.Canonicalize();
-      ISL_Print("Done canonicalizing recursive type '%s': %s\n",
+      THR_Print("Done canonicalizing recursive type '%s': %s\n",
                 String::Handle(Z, type.Name()).ToCString(),
                 type.ToCString());
       return type.raw();
     }
     return parameterized_type.Canonicalize();
   } else {
     return parameterized_type.raw();
   }
 }
 
@@ skipping 680 matching lines @@
       library.LookupLocalClass(inserted_class_name));
   if (inserted_class.IsNull()) {
     inserted_class_name = Symbols::New(inserted_class_name);
     const Script& script = Script::Handle(isolate, mixin_app_class.script());
     inserted_class = Class::New(
         inserted_class_name, script, mixin_app_class.token_pos());
     inserted_class.set_is_synthesized_class();
     library.AddClass(inserted_class);
 
     if (FLAG_trace_class_finalization) {
-      ISL_Print("Creating mixin application alias %s\n",
+      THR_Print("Creating mixin application alias %s\n",
                 inserted_class.ToCString());
     }
 
     // The super type of the inserted class is identical to the super type of
     // this mixin application class, except that it must refer to the type
     // parameters of the inserted class rather than to those of the mixin
     // application class.
     // The type arguments of the super type will be set properly when calling
     // CloneMixinAppTypeParameters on the inserted class, as long as the super
     // type class is set properly.
@@ skipping 114 matching lines @@
   super_type = Type::New(inserted_class,
                          new_super_type_args,
                          mixin_app_class.token_pos());
   mixin_app_class.set_super_type(super_type);
 
   // Mark this mixin application class as being an alias.
   mixin_app_class.set_is_mixin_app_alias();
   ASSERT(!mixin_app_class.is_type_finalized());
   ASSERT(!mixin_app_class.is_mixin_type_applied());
   if (FLAG_trace_class_finalization) {
-    ISL_Print("Inserting class '%s' %s\n"
+    THR_Print("Inserting class '%s' %s\n"
               "  as super type '%s' with %" Pd " type args: %s\n"
               "  of mixin application alias '%s' %s\n",
               String::Handle(inserted_class.Name()).ToCString(),
               TypeArguments::Handle(
                   inserted_class.type_parameters()).ToCString(),
               String::Handle(isolate, super_type.Name()).ToCString(),
               num_super_type_params + num_aliased_mixin_type_params,
               super_type.ToCString(),
               String::Handle(mixin_app_class.Name()).ToCString(),
               TypeArguments::Handle(
                   mixin_app_class.type_parameters()).ToCString());
   }
 }
 
 
 void ClassFinalizer::ApplyMixinType(const Class& mixin_app_class,
                                     PendingTypes* pending_types) {
   if (mixin_app_class.is_mixin_type_applied()) {
     return;
   }
   Type& mixin_type = Type::Handle(mixin_app_class.mixin());
   ASSERT(!mixin_type.IsNull());
   ASSERT(mixin_type.HasResolvedTypeClass());
   const Class& mixin_class = Class::Handle(mixin_type.type_class());
 
   if (FLAG_trace_class_finalization) {
-    ISL_Print("Applying mixin type '%s' to %s at pos %" Pd "\n",
+    THR_Print("Applying mixin type '%s' to %s at pos %" Pd "\n",
               String::Handle(mixin_type.Name()).ToCString(),
               mixin_app_class.ToCString(),
               mixin_app_class.token_pos());
   }
 
   // Check for illegal self references.
   GrowableArray<intptr_t> visited_mixins;
   if (!IsMixinCycleFree(mixin_class, &visited_mixins)) {
     const String& class_name = String::Handle(mixin_class.Name());
     ReportError(mixin_class, mixin_class.token_pos(),
@@ skipping 22 matching lines @@
 
   // Copy type parameters to mixin application class.
   CloneMixinAppTypeParameters(mixin_app_class);
 
   // Verify that no restricted class is used as a mixin by checking the
   // interfaces of the mixin application class, which implements its mixin.
   GrowableArray<intptr_t> visited_interfaces;
   ResolveSuperTypeAndInterfaces(mixin_app_class, &visited_interfaces);
 
   if (FLAG_trace_class_finalization) {
-    ISL_Print("Done applying mixin type '%s' to class '%s' %s extending '%s'\n",
+    THR_Print("Done applying mixin type '%s' to class '%s' %s extending '%s'\n",
               String::Handle(mixin_type.Name()).ToCString(),
               String::Handle(mixin_app_class.Name()).ToCString(),
               TypeArguments::Handle(
                   mixin_app_class.type_parameters()).ToCString(),
               AbstractType::Handle(mixin_app_class.super_type()).ToCString());
   }
   // Mark the application class as having been applied its mixin type in order
   // to avoid cycles while finalizing its mixin type.
   mixin_app_class.set_is_mixin_type_applied();
   // Finalize the mixin type, which may have been changed in case
@@ skipping 24 matching lines @@
     func ^= functions.At(i);
     if (func.IsGenerativeConstructor()) {
       // Build constructor name from mixin application class name
       // and name of cloned super class constructor.
       const String& ctor_name = String::Handle(func.name());
       String& clone_name = String::Handle(
           String::SubString(ctor_name, super_name.Length()));
       clone_name = Symbols::FromConcat(mixin_name, clone_name);
 
       if (FLAG_trace_class_finalization) {
-        ISL_Print("Cloning constructor '%s' as '%s'\n",
+        THR_Print("Cloning constructor '%s' as '%s'\n",
                   ctor_name.ToCString(),
                   clone_name.ToCString());
       }
       const Function& clone = Function::Handle(
           Function::New(clone_name,
                         func.kind(),
                         func.is_static(),
                         false,  // Not const.
                         false,  // Not abstract.
                         false,  // Not external.
@@ skipping 34 matching lines @@
   // If the mixin is a mixin application alias class, there are no members to
   // apply here. A new synthesized class representing the aliased mixin
   // application class was inserted in the super chain of this mixin application
   // class. Members of the actual mixin class will be applied when visiting
   // the mixin application class referring to the actual mixin.
   ASSERT(!mixin_cls.is_mixin_app_alias() ||
          Class::Handle(zone, cls.SuperClass()).IsMixinApplication());
   // A default constructor will be created for the mixin app alias class.
 
   if (FLAG_trace_class_finalization) {
-    ISL_Print("Applying mixin members of %s to %s at pos %" Pd "\n",
+    THR_Print("Applying mixin members of %s to %s at pos %" Pd "\n",
               mixin_cls.ToCString(),
               cls.ToCString(),
               cls.token_pos());
   }
 
   const GrowableObjectArray& cloned_funcs =
       GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
 
   CreateForwardingConstructors(cls, cloned_funcs);
 
@@ skipping 38 matching lines @@
     // Static fields are shared between the mixin class and the mixin
     // application class.
     if (!field.is_static()) {
       const Field& cloned = Field::ZoneHandle(zone, field.Clone(cls));
       cloned_fields.Add(&cloned);
     }
   }
   cls.AddFields(cloned_fields);
 
   if (FLAG_trace_class_finalization) {
-    ISL_Print("Done applying mixin members of %s to %s\n",
+    THR_Print("Done applying mixin members of %s to %s\n",
               mixin_cls.ToCString(),
               cls.ToCString());
   }
 }
 
 
 void ClassFinalizer::FinalizeTypesInClass(const Class& cls) {
   Thread* thread = Thread::Current();
   HANDLESCOPE(thread);
   if (cls.is_type_finalized()) {
     return;
   }
   if (FLAG_trace_class_finalization) {
-    ISL_Print("Finalize types in %s\n", cls.ToCString());
+    THR_Print("Finalize types in %s\n", cls.ToCString());
   }
   if (!IsSuperCycleFree(cls)) {
     const String& name = String::Handle(cls.Name());
     ReportError(cls, cls.token_pos(),
                 "class '%s' has a cycle in its superclass relationship",
                 name.ToCString());
   }
   // Finalize super class.
   Class& super_class = Class::Handle(cls.SuperClass());
   if (!super_class.IsNull()) {
@@ skipping 113 matching lines @@
 }
 
 
 void ClassFinalizer::FinalizeClass(const Class& cls) {
   Thread* thread = Thread::Current();
   HANDLESCOPE(thread);
   if (cls.is_finalized()) {
     return;
   }
   if (FLAG_trace_class_finalization) {
-    ISL_Print("Finalize %s\n", cls.ToCString());
+    THR_Print("Finalize %s\n", cls.ToCString());
   }
   if (cls.is_patch()) {
     // The fields and functions of a patch class are copied to the
     // patched class after parsing. There is nothing to finalize.
     ASSERT(Array::Handle(cls.functions()).Length() == 0);
     ASSERT(Array::Handle(cls.fields()).Length() == 0);
     cls.set_is_finalized();
     return;
   }
   if (cls.IsMixinApplication()) {
@@ skipping 353 matching lines @@
       interfaces.SetAt(0, generic_mixin_type);
       ASSERT(mixin_app_class.interfaces() == Object::empty_array().raw());
       mixin_app_class.set_interfaces(interfaces);
       mixin_app_class.set_is_synthesized_class();
       library.AddClass(mixin_app_class);
 
       // No need to add the new class to pending_classes, since it will be
       // processed via the super_type chain of a pending class.
 
       if (FLAG_trace_class_finalization) {
-        ISL_Print("Creating mixin application %s\n",
+        THR_Print("Creating mixin application %s\n",
                   mixin_app_class.ToCString());
       }
     }
     // This mixin application class becomes the type class of the super type of
     // the next mixin application class. It is however too early to provide the
     // correct super type arguments. We use the raw type for now.
     mixin_super_type = Type::New(mixin_app_class,
                                  Object::null_type_arguments(),
                                  mixin_type.token_pos());
   }
   TypeArguments& mixin_app_args = TypeArguments::Handle(isolate);
   if (type_args.Length() > 0) {
     mixin_app_args = TypeArguments::New(type_args.Length());
     AbstractType& type_arg = AbstractType::Handle(isolate);
     for (intptr_t i = 0; i < type_args.Length(); i++) {
       type_arg ^= type_args.At(i);
       mixin_app_args.SetTypeAt(i, type_arg);
     }
   }
   if (FLAG_trace_class_finalization) {
-    ISL_Print("ResolveMixinAppType: mixin appl type args: %s\n",
+    THR_Print("ResolveMixinAppType: mixin appl type args: %s\n",
               mixin_app_args.ToCString());
   }
   // The mixin application class at depth k is a subclass of mixin application
   // class at depth k - 1. Build a new super type with the class at the highest
   // depth (the last one processed by the loop above) as the type class and the
   // collected type arguments from the super type and all mixin types.
   // This super type replaces the MixinAppType object in the class that extends
   // the mixin application.
   return Type::New(mixin_app_class, mixin_app_args, mixin_app_type.token_pos());
 }
 
 
 // Recursively walks the graph of explicitly declared super type and
 // interfaces, resolving unresolved super types and interfaces.
 // Reports an error if there is an interface reference that cannot be
 // resolved, or if there is a cycle in the graph. We detect cycles by
 // remembering interfaces we've visited in each path through the
 // graph. If we visit an interface a second time on a given path,
 // we found a loop.
 void ClassFinalizer::ResolveSuperTypeAndInterfaces(
     const Class& cls, GrowableArray<intptr_t>* visited) {
   if (cls.is_cycle_free()) {
     return;
   }
   ASSERT(visited != NULL);
   if (FLAG_trace_class_finalization) {
-    ISL_Print("Resolving super and interfaces: %s\n", cls.ToCString());
+    THR_Print("Resolving super and interfaces: %s\n", cls.ToCString());
   }
   Isolate* isolate = Isolate::Current();
   const intptr_t cls_index = cls.id();
   for (intptr_t i = 0; i < visited->length(); i++) {
     if ((*visited)[i] == cls_index) {
       // We have already visited class 'cls'. We found a cycle.
       const String& class_name = String::Handle(isolate, cls.Name());
       ReportError(cls, cls.token_pos(),
                   "cyclic reference found for class '%s'",
                   class_name.ToCString());
@@ skipping 186 matching lines @@
                   class_name.ToCString(), field_name.ToCString());
     }
   }
 }
 
 
 void ClassFinalizer::PrintClassInformation(const Class& cls) {
   Thread* thread = Thread::Current();
   HANDLESCOPE(thread);
   const String& class_name = String::Handle(cls.Name());
-  ISL_Print("class '%s'", class_name.ToCString());
+  THR_Print("class '%s'", class_name.ToCString());
   const Library& library = Library::Handle(cls.library());
   if (!library.IsNull()) {
-    ISL_Print(" library '%s%s':\n",
+    THR_Print(" library '%s%s':\n",
               String::Handle(library.url()).ToCString(),
               String::Handle(library.private_key()).ToCString());
   } else {
-    ISL_Print(" (null library):\n");
+    THR_Print(" (null library):\n");
   }
   const AbstractType& super_type = AbstractType::Handle(cls.super_type());
   if (super_type.IsNull()) {
-    ISL_Print("  Super: NULL");
+    THR_Print("  Super: NULL");
   } else {
     const String& super_name = String::Handle(super_type.Name());
-    ISL_Print("  Super: %s", super_name.ToCString());
+    THR_Print("  Super: %s", super_name.ToCString());
   }
   const Array& interfaces_array = Array::Handle(cls.interfaces());
   if (interfaces_array.Length() > 0) {
-    ISL_Print("; interfaces: ");
+    THR_Print("; interfaces: ");
     AbstractType& interface = AbstractType::Handle();
     intptr_t len = interfaces_array.Length();
     for (intptr_t i = 0; i < len; i++) {
       interface ^= interfaces_array.At(i);
-      ISL_Print("  %s ", interface.ToCString());
+      THR_Print("  %s ", interface.ToCString());
     }
   }
-  ISL_Print("\n");
+  THR_Print("\n");
   const Array& functions_array = Array::Handle(cls.functions());
   Function& function = Function::Handle();
   intptr_t len = functions_array.Length();
   for (intptr_t i = 0; i < len; i++) {
     function ^= functions_array.At(i);
-    ISL_Print("  %s\n", function.ToCString());
+    THR_Print("  %s\n", function.ToCString());
   }
   const Array& fields_array = Array::Handle(cls.fields());
   Field& field = Field::Handle();
   len = fields_array.Length();
   for (intptr_t i = 0; i < len; i++) {
     field ^= fields_array.At(i);
-    ISL_Print("  %s\n", field.ToCString());
+    THR_Print("  %s\n", field.ToCString());
   }
 }
 
 // Either report an error or mark the type as malformed.
 void ClassFinalizer::MarkTypeMalformed(const Error& prev_error,
                                        const Script& script,
                                        const Type& type,
                                        const char* format,
                                        va_list args) {
   LanguageError& error = LanguageError::Handle(
@@ skipping 171 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