Make the "sticky error" an Error instead of a String.

runtime/vm/parser.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/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 872 matching lines @@
                                                    signature_function,
                                                    script_);
         // Record the function signature class in the current library.
         library_.AddClass(signature_class);
       } else {
         signature_function.set_signature_class(signature_class);
       }
       ASSERT(signature_function.signature_class() == signature_class.raw());
       Type& signature_type = Type::ZoneHandle(signature_class.SignatureType());
       if (!is_top_level_ && !signature_type.IsFinalized()) {
-        String& errmsg = String::Handle();
+        Error& error = Error::Handle();
         signature_type ^=
             ClassFinalizer::FinalizeAndCanonicalizeType(signature_class,
                                                         signature_type,
-                                                        &errmsg);
-        if (!errmsg.IsNull()) {
-          ErrorMsg(errmsg.ToCString());
+                                                        &error);
+        if (!error.IsNull()) {
+          ErrorMsg(error.ToErrorCString());
         }
       }
       // The type of the parameter is now the signature type.
       parameter.type = &signature_type;
     }
   }
 
   if (CurrentToken() == Token::kASSIGN) {
     if (!params->has_named_optional_parameters ||
         !allow_explicit_default_value) {
@@ skipping 2924 matching lines @@
     // Patch the function type now that the signature is known.
     // We need to create a new type for proper finalization, since the existing
     // type is already marked as finalized.
     Type& signature_type = Type::Handle(signature_class.SignatureType());
     const AbstractTypeArguments& signature_type_arguments =
         AbstractTypeArguments::Handle(signature_type.arguments());
 
     // Since the signature type is cached by the signature class, it may have
     // been finalized already.
     if (!signature_type.IsFinalized()) {
-      String& errmsg = String::Handle();
+      Error& error = Error::Handle();
       signature_type ^=
           ClassFinalizer::FinalizeAndCanonicalizeType(signature_class,
                                                       signature_type,
-                                                      &errmsg);
-      if (!errmsg.IsNull()) {
-        ErrorMsg(errmsg.ToCString());
+                                                      &error);
+      if (!error.IsNull()) {
+        ErrorMsg(error.ToErrorCString());
       }
       // The call to ClassFinalizer::FinalizeAndCanonicalizeType may have
       // extended the vector of type arguments.
       ASSERT(signature_type_arguments.IsNull() ||
              (signature_type_arguments.Length() ==
               signature_class.NumTypeArguments()));
       // The signature_class should not have changed.
       ASSERT(signature_type.type_class() == signature_class.raw());
     }
 
@@ skipping 1298 matching lines @@
                                 new LoadLocalNode(statement_pos, *trace_var));
     }
   } else {
     statement = ParseExpr(kAllowConst);
     ExpectSemicolon();
   }
   return statement;
 }
 
 
+// Static
+RawError* Parser::FormatError(const Script& script,
+                              intptr_t token_index,
+                              const char* message_header,
+                              const char* format,
+                              va_list args) {
+  const intptr_t kMessageBufferSize = 512;
+  char message_buffer[kMessageBufferSize];
+  FormatMessage(script, token_index, message_header,
+                message_buffer, kMessageBufferSize,
+                format, args);
+  const String& msg = String::Handle(String::New(message_buffer));
+  return LanguageError::New(msg);
+}
+
+
 // Static.
 void Parser::FormatMessage(const Script& script,
                            intptr_t token_index,
                            const char* message_header,
                            char* message_buffer,
                            intptr_t message_buffer_size,
                            const char* format, va_list args) {
   intptr_t msg_len = 0;
   if (!script.IsNull()) {
     const String& script_url = String::CheckedHandle(script.url());
@@ skipping 45 matching lines @@
     // Append the formatted error or warning message.
     msg_len += OS::VSNPrint(message_buffer + msg_len,
                             message_buffer_size - msg_len,
                             format,
                             args);
   }
 }
 
 
 void Parser::ErrorMsg(intptr_t token_index, const char* format, ...) {
-  const intptr_t kMessageBufferSize = 512;
-  char message_buffer[kMessageBufferSize];
   va_list args;
   va_start(args, format);
-  FormatMessage(script_, token_index, "Error",
-                message_buffer, kMessageBufferSize,
-                format, args);
+  const Error& error = Error::Handle(
+      FormatError(script_, token_index, "Error", format, args));
   va_end(args);
-  Isolate::Current()->long_jump_base()->Jump(1, message_buffer);
+  Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 
 void Parser::ErrorMsg(const char* format, ...) {
-  const intptr_t kMessageBufferSize = 512;
-  char message_buffer[kMessageBufferSize];
   va_list args;
   va_start(args, format);
-  FormatMessage(script_, token_index_, "Error",
-                message_buffer, kMessageBufferSize,
-                format, args);
+  const Error& error = Error::Handle(
+      FormatError(script_, token_index_, "Error", format, args));
   va_end(args);
-  Isolate::Current()->long_jump_base()->Jump(1, message_buffer);
+  Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 
 void Parser::Warning(intptr_t token_index, const char* format, ...) {
-  const intptr_t kMessageBufferSize = 512;
-  char message_buffer[kMessageBufferSize];
   if (FLAG_silent_warnings) return;
   va_list args;
   va_start(args, format);
-  FormatMessage(script_, token_index, "Warning",
-                message_buffer, kMessageBufferSize,
-                format, args);
+  const Error& error = Error::Handle(
+      FormatError(script_, token_index, "Warning", format, args));
   va_end(args);
   if (FLAG_warning_as_error) {
-    Isolate::Current()->long_jump_base()->Jump(1, message_buffer);
+    Isolate::Current()->long_jump_base()->Jump(1, error);
     UNREACHABLE();
   } else {
-    OS::Print(message_buffer);
+    OS::Print("%s", error.ToErrorCString());
   }
 }
 
 
 void Parser::Warning(const char* format, ...) {
-  const intptr_t kMessageBufferSize = 512;
-  char message_buffer[kMessageBufferSize];
   if (FLAG_silent_warnings) return;
   va_list args;
   va_start(args, format);
-  FormatMessage(script_, token_index_, "Warning",
-                message_buffer, kMessageBufferSize,
-                format, args);
+  const Error& error = Error::Handle(
+      FormatError(script_, token_index_, "Warning", format, args));
   va_end(args);
   if (FLAG_warning_as_error) {
-    Isolate::Current()->long_jump_base()->Jump(1, message_buffer);
+    Isolate::Current()->long_jump_base()->Jump(1, error);
     UNREACHABLE();
   } else {
-    OS::Print(message_buffer);
+    OS::Print("%s", error.ToErrorCString());
   }
 }
 
 
 void Parser::Unimplemented(const char* msg) {
   ErrorMsg(token_index_, msg);
 }
 
 
 void Parser::ExpectToken(Token::Kind token_expected) {
@@ skipping 1360 matching lines @@
       } else {
         // Check if ident is a type parameter in scope.
         type_parameter = scope_class.LookupTypeParameter(*type_name.ident);
         if (!type_parameter.IsNull()) {
           if (CurrentToken() == Token::kLT) {
             // A type parameter cannot be parameterized.
             ErrorMsg(type_pos, "type parameter '%s' cannot be parameterized",
                      String::Handle(type_parameter.Name()).ToCString());
           }
           if (type_resolution == kMustResolve) {
-            String& errmsg = String::Handle();
+            Error& error = Error::Handle();
             type_parameter ^=
                 ClassFinalizer::FinalizeAndCanonicalizeType(scope_class,
                                                             type_parameter,
-                                                            &errmsg);
-            if (!errmsg.IsNull()) {
-              ErrorMsg(errmsg.ToCString());
+                                                            &error);
+            if (!error.IsNull()) {
+              ErrorMsg(error.ToErrorCString());
             }
           }
           return type_parameter.raw();
         }
       }
     }
     // Try to resolve the type class.
     type_class = LookupTypeClass(type_name, type_resolution);
   }
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::Handle(ParseTypeArguments(type_resolution));
   Type& type = Type::Handle(
       Type::NewParameterizedType(type_class, type_arguments));
   if (type_resolution == kMustResolve) {
     ASSERT(type_class.IsClass());  // Must be resolved.
-    String& errmsg = String::Handle();
+    Error& error = Error::Handle();
     type ^= ClassFinalizer::FinalizeAndCanonicalizeType(scope_class,
                                                         type,
-                                                        &errmsg);
-    if (!errmsg.IsNull()) {
-      ErrorMsg(errmsg.ToCString());
+                                                        &error);
+    if (!error.IsNull()) {
+      ErrorMsg(error.ToErrorCString());
     }
   }
   return type.raw();
 }
 
 
 void Parser::CheckConstructorCallTypeArguments(
     intptr_t pos, Function& constructor,
     const AbstractTypeArguments& type_arguments) {
   if (!type_arguments.IsNull()) {
@@ skipping 531 matching lines @@
     if (constructor.IsFactory() &&
         (constructor.signature_class() != Class::null())) {
       signature_class = constructor.signature_class();
     } else {
       signature_class = constructor.owner();
       ASSERT(signature_class.raw() == type_class.raw());
     }
     // TODO(regis): Temporary type should be allocated in new gen heap.
     Type& type = Type::Handle(
         Type::NewParameterizedType(signature_class, type_arguments));
-    String& errmsg = String::Handle();
+    Error& error = Error::Handle();
     type ^= ClassFinalizer::FinalizeAndCanonicalizeType(signature_class,
                                                         type,
-                                                        &errmsg);
-    if (!errmsg.IsNull()) {
-      ErrorMsg(errmsg.ToCString());
+                                                        &error);
+    if (!error.IsNull()) {
+      ErrorMsg(error.ToErrorCString());
     }
     // The type argument vector may have been expanded with the type arguments
     // of the super type when finalizing the type.
     type_arguments = type.arguments();
   }
 
   type_arguments ^= type_arguments.Canonicalize();
   // Make the constructor call.
   AstNode* new_object = NULL;
   if (is_const) {
@@ skipping 456 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart