Fix Issue 1846: Improve error reporting in presence of imports. With this CL:

runtime/vm/parser.cc

 // Copyright (c) 2012, 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 3292 matching lines @@
                                           const Array& import_map) {
   Dart_LibraryTagHandler handler = Isolate::Current()->library_tag_handler();
   if (handler == NULL) {
     ErrorMsg(token_pos, "no library handler registered");
   }
   Dart_Handle result = handler(tag,
                                Api::NewLocalHandle(library_),
                                Api::NewLocalHandle(url),
                                Api::NewLocalHandle(import_map));
   if (Dart_IsError(result)) {
-    ErrorMsg(token_pos, "library handler failed: %s", Dart_GetError(result));
+    AppendErrorMsg(
+        Dart_GetError(result), token_pos, "library handler failed");

[hausner, 2012/02/29 22:56:02]

Dart_GetError() copies the error message out of an error object into a C string,
then you pass it to to a function that copies the C string into a Dart string
which is copied again when the old and new error message concatenated. 

This can probably be done with one less indirection. What if you pass the error
object into AppendErrorMsg()?

[srdjan, 2012/02/29 23:47:04]

Done.

   }
   return result;
 }
 
 
 void Parser::ParseLibraryImport() {
   TRACE_PARSER("ParseLibraryImport");
   while (CurrentToken() == Token::kIMPORT) {
     const intptr_t import_pos = token_index_;
     ConsumeToken();
@@ skipping 1923 matching lines @@
                                 new LoadLocalNode(statement_pos, *trace_var));
     }
   } else {
     statement = ParseExpr(kAllowConst);
     ExpectSemicolon();
   }
   return statement;
 }
 
 
+RawError* Parser::FormatErrorWithAppend(const char* prev_error,
+                                        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& msg1 = String::Handle(String::New(prev_error));
+  const String& msg2 = String::Handle(String::New(message_buffer));
+  return LanguageError::New(String::Handle(String::Concat(msg1, msg2)));
+}
+
+
 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);
@@ skipping 80 matching lines @@
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
       FormatError(script_, token_index_, "Error", format, args));
   va_end(args);
   Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 
+void Parser::AppendErrorMsg(
+      const char* prev_error, intptr_t token_index, const char* format, ...) {
+  va_list args;
+  va_start(args, format);
+  const Error& error = Error::Handle(FormatErrorWithAppend(
+      prev_error, script_, token_index, "Error", format, args));
+  va_end(args);
+  Isolate::Current()->long_jump_base()->Jump(1, error);
+  UNREACHABLE();
+}
+
+
 void Parser::Warning(intptr_t token_index, const char* format, ...) {
   if (FLAG_silent_warnings) return;
   va_list args;
   va_start(args, format);
   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, error);
     UNREACHABLE();
@@ skipping 2609 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart