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));
+    Error& prev_error = Error::Handle();
+    prev_error ^= Api::UnwrapHandle(result);
+    AppendErrorMsg(prev_error, token_pos, "library handler failed");
   }
   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 Error& 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.ToErrorCString()));

[hausner, 2012/03/01 00:10:16]

Why not use prev_error.message()? There is still a detour through C land in your
version.

[srdjan, 2012/03/01 00:17:34]

There is no Error::message(). Some subclasses implement it, some don't. All
implement ToErrorCString, although some have UNREACHABLE in them.

[turnidge, 2012/03/07 00:41:21]

You should be able to use ToErrorCString on any real Error object.  Nobody is
using UnwindErrors yet, so the UNIMPLEMENTED there doesn't matter.  All other
subclasses of Error have reasonable implementations.

+  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 Error& 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