- Fix outdated use of factory clause.

vm/class_finalizer.cc

 // Copyright (c) 2011, 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 55 matching lines @@
     ASSERT(!class_array.IsNull());
     Class& cls = Class::Handle();
     // First resolve all superclasses.
     for (intptr_t i = 0; i < class_array.Length(); i++) {
       cls ^= class_array.At(i);
       if (FLAG_trace_class_finalization) {
         OS::Print("Resolving super and default: %s\n", cls.ToCString());
       }
       ResolveSuperType(cls);
       if (cls.is_interface()) {
-        ResolveFactoryClass(cls);
+        ResolveDefaultClass(cls);
       }
     }
     // Finalize all classes.
     for (intptr_t i = 0; i < class_array.Length(); i++) {
       cls ^= class_array.At(i);
       FinalizeClass(cls, generating_snapshot);
     }
     if (FLAG_print_classes) {
       for (intptr_t i = 0; i < class_array.Length(); i++) {
         cls ^= class_array.At(i);
@@ skipping 256 matching lines @@
       ReportError(script, -1,
                   "'%s' is not allowed to extend '%s'\n",
                   String::Handle(cls.Name()).ToCString(),
                   String::Handle(super_class.Name()).ToCString());
     }
   }
   return;
 }
 
 
-void ClassFinalizer::ResolveFactoryClass(const Class& interface) {
+void ClassFinalizer::ResolveDefaultClass(const Class& interface) {
   ASSERT(interface.is_interface());
   if (interface.is_finalized() ||
       !interface.HasFactoryClass() ||
       interface.HasResolvedFactoryClass()) {
     return;
   }
   const UnresolvedClass& unresolved_factory_class =
       UnresolvedClass::Handle(interface.UnresolvedFactoryClass());
 
   // Lookup the factory class.
   const Class& factory_class =
       Class::Handle(ResolveClass(interface, unresolved_factory_class));
   ASSERT(!factory_class.IsNull());
   if (factory_class.is_interface()) {
     const String& interface_name = String::Handle(interface.Name());
     const String& factory_name = String::Handle(factory_class.Name());
     const Script& script = Script::Handle(interface.script());
     ReportError(script, unresolved_factory_class.token_index(),
-                "factory clause of interface '%s' names non-class '%s'.\n",
+                "default clause of interface '%s' names non-class '%s'.\n",
                 interface_name.ToCString(),
                 factory_name.ToCString());
   }
   interface.set_factory_class(factory_class);
   // Check that the type parameter lists are identical.
   const Class& factory_signature_class = Class::Handle(
       unresolved_factory_class.factory_signature_class());
   ASSERT(!factory_signature_class.IsNull());
   ResolveAndFinalizeUpperBounds(factory_class);
   ResolveAndFinalizeUpperBounds(factory_signature_class);
   const intptr_t num_type_params = factory_signature_class.NumTypeParameters();
   bool mismatch = factory_class.NumTypeParameters() != num_type_params;
   if (mismatch && (num_type_params == 0)) {
     // TODO(regis): For now, and until the core lib is fixed, we accept a
     // factory clause with a class missing its list of type parameters.
     // See bug 5408808.
     const String& interface_name = String::Handle(interface.Name());
     const String& factory_name = String::Handle(factory_class.Name());
     const Script& script = Script::Handle(interface.script());
     ReportWarning(script, unresolved_factory_class.token_index(),
-                  "class '%s' in factory clause of interface '%s' is "
+                  "class '%s' in default clause of interface '%s' is "
                   "missing its type parameter list.\n",
                   factory_name.ToCString(),
                   interface_name.ToCString());
     return;
   }
   String& expected_type_name = String::Handle();
   String& actual_type_name = String::Handle();
   AbstractType& expected_type_extends = AbstractType::Handle();
   AbstractType& actual_type_extends = AbstractType::Handle();
   const Array& expected_type_names =
@@ skipping 899 matching lines @@
   va_end(args);
   if (FLAG_warning_as_error) {
     Isolate::Current()->long_jump_base()->Jump(1, message_buffer);
     UNREACHABLE();
   } else {
     OS::Print(message_buffer);
   }
 }
 
 }  // namespace dart