Update comments in core lib showing proper factory syntax.

runtime/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"
 #include "vm/object_store.h"
+#include "vm/parser.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_classes, false, "Prints details about loaded classes.");
 DEFINE_FLAG(bool, trace_class_finalization, false, "Trace class finalization.");
 DEFINE_FLAG(bool, trace_type_finalization, false, "Trace type finalization.");
 DEFINE_FLAG(bool, verify_implements, false,
     "Verify that all classes implement their interface.");
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, silent_warnings);
@@ skipping 274 matching lines @@
     String& type_parameter_name = String::Handle(super_type.Name());
     ReportError("'%s' cannot extend or implement type parameter '%s'.\n",
                 class_name.ToCString(),
                 type_parameter_name.ToCString());
   }
   cls.set_super_type(super_type);
   const Class& super_class = Class::Handle(super_type.type_class());
   if (cls.is_interface() != super_class.is_interface()) {
     String& class_name = String::Handle(cls.Name());
     String& super_class_name = String::Handle(super_class.Name());
-    ReportError("class '%s' and superclass '%s' are not "
+    const Script& script = Script::Handle(cls.script());
+    ReportError(script, -1,
+                "class '%s' and superclass '%s' are not "
                 "both classes or both interfaces.\n",
                 class_name.ToCString(),
                 super_class_name.ToCString());
   }
   // If cls belongs to core lib or to core lib's implementation, restrictions
   // about allowed interfaces are lifted.
   if ((cls.library() != Library::CoreLibrary()) &&
       (cls.library() != Library::CoreImplLibrary())) {
     // Prevent extending core implementation classes Bool, Double, ObjectArray,
     // ImmutableArray, GrowableObjectArray, IntegerImplementation, Smi, Mint,
@@ skipping 14 matching lines @@
         (super_class.raw() == object_store->immutable_array_class()) ||
         (super_class.raw() == growable_object_array_class.raw()) ||
         (super_class.raw() == object_store->byte_buffer_class()) ||
         (super_class.raw() == integer_implementation_class.raw()) ||
         (super_class.raw() == object_store->smi_class()) ||
         (super_class.raw() == object_store->mint_class()) ||
         (super_class.raw() == object_store->bigint_class()) ||
         (super_class.raw() == object_store->one_byte_string_class()) ||
         (super_class.raw() == object_store->two_byte_string_class()) ||
         (super_class.raw() == object_store->four_byte_string_class())) {
-      ReportError("'%s' is not allowed to extend '%s'\n",
+      const Script& script = Script::Handle(cls.script());
+      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) {
   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());
-    ReportError("factory clause of interface '%s' names non-class '%s'.\n",
+    const Script& script = Script::Handle(interface.script());
+    ReportError(script, unresolved_factory_class.token_index(),
+                "factory 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());
-    ReportWarning("Warning: class '%s' in factory clause of interface '%s' is "
+    const Script& script = Script::Handle(interface.script());
+    ReportWarning(script, unresolved_factory_class.token_index(),
+                  "class '%s' in factory 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();
   Type& expected_type_extends = Type::Handle();
   Type& actual_type_extends = Type::Handle();
   const Array& expected_type_names =
@@ skipping 11 matching lines @@
     actual_type_extends = actual_extends_array.TypeAt(i);
     if (!expected_type_name.Equals(actual_type_name) ||
         !expected_type_extends.Equals(actual_type_extends)) {
       mismatch = true;
     }
   }
   if (mismatch) {
     const String& interface_name = String::Handle(interface.Name());
     const String& factory_name = String::Handle(factory_class.Name());
     // TODO(regis): Report the filename and position as well.
-    ReportError("mismatch in number or names of type parameters between "
+    const Script& script = Script::Handle(interface.script());
+    ReportError(script, unresolved_factory_class.token_index(),
+                "mismatch in number or names of type parameters between "
                 "factory clause of interface '%s' and actual factory "
                 "class '%s'.\n",
                 interface_name.ToCString(),
                 factory_name.ToCString());
   }
 }
 
 
 // TODO(regis): Now that we do not resolve type parameters anymore, we could
 // make this function void and resolve the type in place.
@@ skipping 103 matching lines @@
       if (type.IsInstantiated()) {
         if (!type_extends.IsInstantiated()) {
           type_extends = type_extends.InstantiateFrom(arguments, offset);
         }
         // TODO(regis): Where do we check the constraints when the type is
         // generic?
         if (!type.IsSubtypeOf(type_extends)) {
           const String& type_argument_name = String::Handle(type.Name());
           const String& class_name = String::Handle(cls.Name());
           const String& extends_name = String::Handle(type_extends.Name());
-          ReportError("type argument '%s' of class '%s' "
+          const Script& script = Script::Handle(cls.script());
+          ReportError(script, -1,
+                      "type argument '%s' of class '%s' "
                       "does not extend type '%s'\n",
                       type_argument_name.ToCString(),
                       class_name.ToCString(),
                       extends_name.ToCString());
         }
       }
     }
   }
   Type& super_type = Type::Handle(cls.super_type());
   if (!super_type.IsNull()) {
@@ skipping 162 matching lines @@
       if (factory_signature_class.NumTypeParameters() !=
           type_class.NumTypeParameters()) {
         const String& function_name = String::Handle(function.name());
         if (factory_signature_class.NumTypeParameters() == 0) {
           // TODO(regis): For now, and until the core lib is fixed, we accept a
           // factory method with missing list of type parameters and use the
           // list of the enclosing class.
           // See bug 5408808.
           const Class& enclosing_class = Class::Handle(function.owner());
           function.set_signature_class(enclosing_class);
-          ReportWarning("Warning: factory method '%s' should declare a list of "
+          const Script& script = Script::Handle(enclosing_class.script());
+          ReportWarning(script, unresolved_type_class.token_index(),
+                        "factory method '%s' should declare a list of "
                         "%d type parameter%s.\n",
                         function_name.ToCString(),
                         type_class.NumTypeParameters(),
                         type_class.NumTypeParameters() > 1 ? "s" : "");
         } else {
-          // TODO(regis): Report the filename and position as well.
-          ReportError("factory method '%s' must declare %d type parameter%s.\n",
+          const Class& enclosing_class = Class::Handle(function.owner());
+          const Script& script = Script::Handle(enclosing_class.script());
+          ReportError(script, unresolved_type_class.token_index(),
+                      "factory method '%s' must declare %d type parameter%s.\n",
                       function_name.ToCString(),
                       type_class.NumTypeParameters(),
                       type_class.NumTypeParameters() > 1 ? "s" : "");
         }
       }
     } else {
       type = ResolveType(cls, type);
       function.set_result_type(type);
     }
   }
@@ skipping 92 matching lines @@
     type = field.type();
     type = ResolveType(cls, type);
     field.set_type(type);
     type = FinalizeType(type);
     field.set_type(type);
     name = field.name();
     super_class = FindSuperOwnerOfInstanceMember(cls, name);
     if (!super_class.IsNull()) {
       const String& class_name = String::Handle(cls.Name());
       const String& super_class_name = String::Handle(super_class.Name());
-      ReportError("field '%s' of class '%s' conflicts with instance "
+      const Script& script = Script::Handle(cls.script());
+      ReportError(script, field.token_index(),
+                  "field '%s' of class '%s' conflicts with instance "
                   "member '%s' of super class '%s'.\n",
                   name.ToCString(),
                   class_name.ToCString(),
                   name.ToCString(),
                   super_class_name.ToCString());
     }
   }
   // Resolve function signatures and check for conflicts in super classes.
   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++) {
     function ^= array.At(i);
     ResolveAndFinalizeSignature(cls, function);
     function_name = function.name();
     if (function.is_static()) {
       super_class = FindSuperOwnerOfInstanceMember(cls, function_name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(cls.Name());
         const String& super_class_name = String::Handle(super_class.Name());
-        ReportError("static function '%s' of class '%s' conflicts with "
+        const Script& script = Script::Handle(cls.script());
+        ReportError(script, function.token_index(),
+                    "static function '%s' of class '%s' conflicts with "
                     "instance member '%s' of super class '%s'.\n",
                     function_name.ToCString(),
                     class_name.ToCString(),
                     function_name.ToCString(),
                     super_class_name.ToCString());
       }
     } else {
       // TODO(regis): This arity check is still being debated. Revisit.
       super_class = cls.SuperClass();
       while (!super_class.IsNull()) {
         overridden_function = super_class.LookupDynamicFunction(function_name);
         if (!overridden_function.IsNull() &&
           !function.HasCompatibleParametersWith(overridden_function)) {
           // Function types are purposely not checked for subtyping.
           const String& class_name = String::Handle(cls.Name());
           const String& super_class_name = String::Handle(super_class.Name());
-          ReportError("class '%s' overrides function '%s' of super class '%s' "
+          const Script& script = Script::Handle(cls.script());
+          ReportError(script, function.token_index(),
+                      "class '%s' overrides function '%s' of super class '%s' "
                       "with incompatible parameters.\n",
                       class_name.ToCString(),
                       function_name.ToCString(),
                       super_class_name.ToCString());
         }
         super_class = super_class.SuperClass();
       }
     }
     if (function.kind() == RawFunction::kGetterFunction) {
       name = Field::NameFromGetter(function_name);
       super_class = FindSuperOwnerOfFunction(cls, name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(cls.Name());
         const String& super_class_name = String::Handle(super_class.Name());
-        ReportError("getter '%s' of class '%s' conflicts with "
+        const Script& script = Script::Handle(cls.script());
+        ReportError(script, function.token_index(),
+                    "getter '%s' of class '%s' conflicts with "
                     "function '%s' of super class '%s'.\n",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
     } else if (function.kind() == RawFunction::kSetterFunction) {
       name = Field::NameFromSetter(function_name);
       super_class = FindSuperOwnerOfFunction(cls, name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(cls.Name());
         const String& super_class_name = String::Handle(super_class.Name());
-        ReportError("setter '%s' of class '%s' conflicts with "
+        const Script& script = Script::Handle(cls.script());
+        ReportError(script, function.token_index(),
+                    "setter '%s' of class '%s' conflicts with "
                     "function '%s' of super class '%s'.\n",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
     } else {
       name = Field::GetterName(function_name);
       super_class = FindSuperOwnerOfFunction(cls, name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(cls.Name());
         const String& super_class_name = String::Handle(super_class.Name());
-        ReportError("function '%s' of class '%s' conflicts with "
+        const Script& script = Script::Handle(cls.script());
+        ReportError(script, function.token_index(),
+                    "function '%s' of class '%s' conflicts with "
                     "getter '%s' of super class '%s'.\n",
                     function_name.ToCString(),
                     class_name.ToCString(),
                     function_name.ToCString(),
                     super_class_name.ToCString());
       }
       name = Field::SetterName(function_name);
       super_class = FindSuperOwnerOfFunction(cls, name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(cls.Name());
         const String& super_class_name = String::Handle(super_class.Name());
-        ReportError("function '%s' of class '%s' conflicts with "
+        const Script& script = Script::Handle(cls.script());
+        ReportError(script, function.token_index(),
+                    "function '%s' of class '%s' conflicts with "
                     "setter '%s' of super class '%s'.\n",
                     function_name.ToCString(),
                     class_name.ToCString(),
                     function_name.ToCString(),
                     super_class_name.ToCString());
       }
     }
   }
 }
 
 
 void ClassFinalizer::FinalizeClass(const Class& cls) {
   if (cls.is_finalized()) {
     return;
   }
   if (FLAG_trace_class_finalization) {
     OS::Print("Finalize %s\n", cls.ToCString());
   }
   // Signature classes are finalized upon creation.
   ASSERT(!cls.IsSignatureClass());
   if (!IsSuperCycleFree(cls)) {
     const String& name = String::Handle(cls.Name());
-    ReportError("class '%s' has a cycle in its superclass relationship.\n",
+    const Script& script = Script::Handle(cls.script());
+    ReportError(script, -1,
+                "class '%s' has a cycle in its superclass relationship.\n",
                 name.ToCString());
   }
   GrowableArray<const Class*> visited;
   ResolveInterfaces(cls, &visited);
   Type& super_type = Type::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     const Class& super_class = Class::Handle(super_type.type_class());
     // Finalize super class and super type.
     FinalizeClass(super_class);
     super_type = FinalizeType(super_type);
@@ skipping 29 matching lines @@
   if (cls.is_const()) {
     CheckForLegalConstClass(cls);
   }
   // Check to ensure we don't have classes with native fields in libraries
   // which do not have a native resolver.
   if (cls.num_native_fields() != 0) {
     const Library& lib = Library::Handle(cls.library());
     if (lib.native_entry_resolver() == NULL) {
       const String& cls_name = String::Handle(cls.Name());
       const String& lib_name = String::Handle(lib.url());
-      ReportError("class '%s' is trying to extend a native fields class,"
+      const Script& script = Script::Handle(cls.script());
+      ReportError(script, -1,
+                  "class '%s' is trying to extend a native fields class, "
                   "but library '%s' has no native resolvers",
                   cls_name.ToCString(), lib_name.ToCString());
     }
   }
 }
 
 
 bool ClassFinalizer::IsSuperCycleFree(const Class& cls) {
   Class& test1 = Class::Handle(cls.raw());
   Class& test2 = Class::Handle(cls.SuperClass());
@@ skipping 59 matching lines @@
 // 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::ResolveInterfaces(const Class& cls,
                                        GrowableArray<const Class*>* visited) {
   ASSERT(visited != NULL);
   for (int i = 0; i < visited->length(); i++) {
     if ((*visited)[i]->raw() == cls.raw()) {
       // We have already visited interface class 'cls'. We found a cycle.
       const String& interface_name = String::Handle(cls.Name());
-      ReportError("Cyclic reference found for interface '%s'\n",
+      const Script& script = Script::Handle(cls.script());
+      ReportError(script, -1,
+                  "Cyclic reference found for interface '%s'\n",
                   interface_name.ToCString());
     }
   }
 
   // If the class/interface has no explicit interfaces, we are done.
   Array& super_interfaces = Array::Handle(cls.interfaces());
   if (super_interfaces.Length() == 0) {
     return;
   }
 
   // If cls belongs to core lib or to core lib's implementation, restrictions
   // about allowed interfaces are lifted.
   const bool cls_belongs_to_core_lib =
       (cls.library() == Library::CoreLibrary()) ||
       (cls.library() == Library::CoreImplLibrary());
 
   // Resolve and check the interfaces of cls.
   visited->Add(&cls);
   Type& interface = Type::Handle();
   for (intptr_t i = 0; i < super_interfaces.Length(); i++) {
     interface ^= super_interfaces.At(i);
     interface = ResolveType(cls, interface);
     super_interfaces.SetAt(i, interface);
     if (interface.IsTypeParameter()) {
-      ReportError("Type parameter '%s' cannot be used as interface\n",
+      const Script& script = Script::Handle(cls.script());
+      ReportError(script, -1,
+                  "Type parameter '%s' cannot be used as interface\n",
                   String::Handle(interface.Name()).ToCString());
     }
     const Class& interface_class = Class::Handle(interface.type_class());
     if (!interface_class.is_interface()) {
-      ReportError("Class '%s' is used where an interface is expected\n",
+      const Script& script = Script::Handle(cls.script());
+      ReportError(script, -1,
+                  "Class '%s' is used where an interface is expected\n",
                   String::Handle(interface_class.Name()).ToCString());
     }
     // Verify that unless cls belongs to core lib, it cannot extend or implement
     // any of bool, num, int, double, String, Function, Dynamic.
     // The exception is signature classes, which are compiler generated and
     // represent a function type, therefore implementing the Function interface.
     if (!cls_belongs_to_core_lib) {
       if (interface.IsBoolInterface() ||
           interface.IsNumberInterface() ||
           interface.IsIntInterface() ||
           interface.IsDoubleInterface() ||
           interface.IsStringInterface() ||
           (interface.IsFunctionInterface() && !cls.IsSignatureClass()) ||
           interface.IsDynamicType()) {
-        ReportError("'%s' is not allowed to extend or implement '%s'\n",
+        const Script& script = Script::Handle(cls.script());
+        ReportError(script, -1,
+                    "'%s' is not allowed to extend or implement '%s'\n",
                     String::Handle(cls.Name()).ToCString(),
                     String::Handle(interface_class.Name()).ToCString());
       }
     }
     // Now resolve the super interfaces.
     ResolveInterfaces(interface_class, visited);
   }
   visited->RemoveLast();
 }
 
 
 // A class is marked as constant if it has one constant constructor.
 // A constant class:
 // - may extend only const classes.
 // - has only const instance fields.
 // Note: we must check for cycles before checking for const properties.
 void ClassFinalizer::CheckForLegalConstClass(const Class& cls) {
   ASSERT(cls.is_const());
   const Class& super = Class::Handle(cls.SuperClass());
   if (!super.IsNull() && !super.is_const()) {
     String& name = String::Handle(super.Name());
-    ReportError("superclass '%s' must be const.\n", name.ToCString());
+    const Script& script = Script::Handle(cls.script());
+    ReportError(script, -1,
+                "superclass '%s' must be const.\n", name.ToCString());
   }
   const Array& fields_array = Array::Handle(cls.fields());
   intptr_t len = fields_array.Length();
   Field& field = Field::Handle();
   for (intptr_t i = 0; i < len; i++) {
     field ^= fields_array.At(i);
     if (!field.is_static() && !field.is_final()) {
       const String& class_name = String::Handle(cls.Name());
       const String& field_name = String::Handle(field.name());
-      ReportError("const class '%s' has non-final field '%s'\n",
+      const Script& script = Script::Handle(cls.script());
+      ReportError(script, field.token_index(),
+                  "const class '%s' has non-final field '%s'\n",
                   class_name.ToCString(), field_name.ToCString());
     }
   }
 }
 
 
 void ClassFinalizer::PrintClassInformation(const Class& cls) {
   HANDLESCOPE();
   const String& class_name = String::Handle(cls.Name());
   OS::Print("%s '%s'",
@@ skipping 27 matching lines @@
   for (intptr_t i = 0; i < len; i++) {
     field ^= fields_array.At(i);
     OS::Print("  %s\n", field.ToCString());
   }
 }
 
 
 void ClassFinalizer::ReportError(const Script& script,
                                  intptr_t token_index,
                                  const char* format, ...) {
-  static const int kBufferLength = 1024;
-  Isolate* isolate = Isolate::Current();
-  ASSERT(isolate != NULL);
-  Zone* zone = isolate->current_zone();
-  ASSERT(zone != NULL);
-  char* msg_buffer = reinterpret_cast<char*>(zone->Allocate(kBufferLength + 1));
-
-  const String& script_url = String::CheckedHandle(script.url());
-  const int buf_size = 256;
-  static char text_buffer[buf_size];
-  intptr_t line, column;
-  script.GetTokenLocation(token_index, &line, &column);
+  const intptr_t kMessageBufferSize = 512;
+  char message_buffer[kMessageBufferSize];
   va_list args;
   va_start(args, format);
-  OS::VSNPrint(text_buffer, buf_size, format, args);
-  va_end(args);
-
-  intptr_t msg_len = OS::SNPrint(msg_buffer, kBufferLength,
-                                 "'%s': line %d pos %d: %s\n",
-                                 script_url.ToCString(),
-                                 line, column, text_buffer);
-  const String& text = String::Handle(script.GetLine(line));
-  ASSERT(!text.IsNull());
-  if (text.Length() < buf_size) {
-    OS::SNPrint(msg_buffer + msg_len, (kBufferLength - msg_len), "%s\n%*s\n",
-                text.ToCString(), column, "^");
-  }
-  isolate->long_jump_base()->Jump(1, msg_buffer);
+  Parser::FormatMessage(script, token_index, "Error",
+                        message_buffer, kMessageBufferSize,
+                        format, args);
+  Isolate::Current()->long_jump_base()->Jump(1, message_buffer);
   UNREACHABLE();
 }
 
 
 void ClassFinalizer::ReportError(const char* format, ...) {
-  static const int kBufferLength = 1024;
-  Isolate* isolate = Isolate::Current();
-  ASSERT(isolate != NULL);
-  Zone* zone = isolate->current_zone();
-  ASSERT(zone != NULL);
-  char* msg_buffer = reinterpret_cast<char*>(zone->Allocate(kBufferLength + 1));
-  ASSERT(msg_buffer != NULL);
+  const intptr_t kMessageBufferSize = 512;
+  char message_buffer[kMessageBufferSize];
   va_list args;
   va_start(args, format);
-  OS::VSNPrint(msg_buffer, kBufferLength, format, args);
+  Parser::FormatMessage(Script::Handle(), -1, "Error",
+                        message_buffer, kMessageBufferSize,
+                        format, args);
   va_end(args);
-  isolate->long_jump_base()->Jump(1, msg_buffer);
+  Isolate::Current()->long_jump_base()->Jump(1, message_buffer);
   UNREACHABLE();
 }
 
-void ClassFinalizer::ReportWarning(const char* format, ...) {
+
+void ClassFinalizer::ReportWarning(const Script& script,
+                                  intptr_t token_index,
+                                  const char* format, ...) {
   if (FLAG_silent_warnings) return;
-  static const int kBufferLength = 1024;
-  Isolate* isolate = Isolate::Current();
-  ASSERT(isolate != NULL);
-  Zone* zone = isolate->current_zone();
-  ASSERT(zone != NULL);
-  char* msg_buffer = reinterpret_cast<char*>(zone->Allocate(kBufferLength + 1));
-  ASSERT(msg_buffer != NULL);
+  const intptr_t kMessageBufferSize = 512;
+  char message_buffer[kMessageBufferSize];
   va_list args;
   va_start(args, format);
-  OS::VSNPrint(msg_buffer, kBufferLength, format, args);
+  Parser::FormatMessage(script, token_index, "Warning",
+                        message_buffer, kMessageBufferSize,
+                        format, args);
   va_end(args);
   if (FLAG_warning_as_error) {
-    isolate->long_jump_base()->Jump(1, msg_buffer);
+    Isolate::Current()->long_jump_base()->Jump(1, message_buffer);
     UNREACHABLE();
   } else {
-    OS::Print(msg_buffer);
+    OS::Print(message_buffer);
   }
 }
 
 }  // namespace dart