Dart_PropagateError, take 2.

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 81 matching lines @@
   for (int i = 0; i < objs.length(); i++) {
     a.SetTypeAt(i, *objs[i]);
   }
   // Cannot canonicalize TypeArgument yet as its types may not have been
   // finalized yet.
   return a.raw();
 }
 
 
 static ThrowNode* CreateEvalConstConstructorThrow(intptr_t token_pos,
-                                                  const Instance& instance) {
+                                                  const Object& obj) {
   UnhandledException& excp = UnhandledException::Handle();
-  excp ^= instance.raw();
+  excp ^= obj.raw();
   const Instance& exception = Instance::ZoneHandle(excp.exception());
   const Instance& stack_trace = Instance::ZoneHandle(excp.stacktrace());
   return new ThrowNode(token_pos,
                        new LiteralNode(token_pos, exception),
                        new LiteralNode(token_pos, stack_trace));
 }
 
 
 struct Parser::Block : public ZoneAllocated {
   Block(Block* outer_block, LocalScope* local_scope, SequenceNode* seq)
@@ skipping 106 matching lines @@
   if (position < token_index_ && position != 0) {
     CompilerStats::num_tokens_rewind += (token_index_ - position);
   }
   token_index_ = position;
   token_kind_ = Token::kILLEGAL;
 }
 
 
 void Parser::ParseCompilationUnit(const Library& library,
                                   const Script& script) {
+  ASSERT(Isolate::Current()->long_jump_base()->IsSafeToJump());
   TimerScope timer(FLAG_compiler_stats, &CompilerStats::parser_timer);
   Parser parser(script, library);
   parser.ParseTopLevel();
   if (FLAG_compiler_stats) {
     CompilerStats::num_tokens_total += parser.tokens_.Length();
   }
 }
 
 
 Token::Kind Parser::CurrentToken() {
@@ skipping 303 matching lines @@
     return HasReturnNode(seq->NodeAt(seq->length() - 1)->AsSequenceNode());
   } else {
     return seq->NodeAt(seq->length() - 1)->IsReturnNode();
   }
 }
 
 
 void Parser::ParseFunction(ParsedFunction* parsed_function) {
   TimerScope timer(FLAG_compiler_stats, &CompilerStats::parser_timer);
   Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->long_jump_base()->IsSafeToJump());
   // Compilation can be nested, preserve the ast node id.
   const int prev_ast_node_id = isolate->ast_node_id();
   isolate->set_ast_node_id(0);
   ASSERT(parsed_function != NULL);
   const Function& func = parsed_function->function();
   const Class& cls = Class::Handle(isolate, func.owner());
   const Script& script = Script::Handle(isolate, cls.script());
   Parser parser(script, func, func.token_index());
   SequenceNode* node_sequence = NULL;
   Array& default_parameter_values = Array::Handle(isolate, Array::null());
@@ skipping 5763 matching lines @@
     const int kNumArguments = 0;  // no arguments.
     const Array& kNoArgumentNames = Array::Handle();
     const Function& func =
         Function::Handle(Resolver::ResolveStatic(cls,
                                                  getter_name,
                                                  kNumArguments,
                                                  kNoArgumentNames,
                                                  Resolver::kIsQualified));
     ASSERT(!func.IsNull());
     ASSERT(func.kind() == RawFunction::kConstImplicitGetter);
-    Instance& const_value = Instance::Handle(
+    Object& const_value = Object::Handle(
         DartEntry::InvokeStatic(func, arguments, kNoArgumentNames));
-    if (const_value.IsUnhandledException()) {
-      ErrorMsg("exception thrown in Parser::RunStaticFieldInitializer");
+    if (const_value.IsError()) {
+      if (const_value.IsUnhandledException()) {
+        ErrorMsg("exception thrown in Parser::RunStaticFieldInitializer");
+      } else {
+        Error& error = Error::Handle();
+        error ^= const_value.raw();
+        Isolate::Current()->long_jump_base()->Jump(1, error);
+      }
     }
-    if (!const_value.IsNull()) {
-      const_value ^= const_value.Canonicalize();
+    ASSERT(const_value.IsNull() || const_value.IsInstance());
+    Instance& instance = Instance::Handle();
+    instance ^= const_value.raw();
+    if (!instance.IsNull()) {
+      instance ^= instance.Canonicalize();
     }
-    field.set_value(const_value);
+    field.set_value(instance);
   }
 }
 
 
-RawInstance* Parser::EvaluateConstConstructorCall(
+RawObject* Parser::EvaluateConstConstructorCall(
     const Class& type_class,
     const AbstractTypeArguments& type_arguments,
     const Function& constructor,
     ArgumentListNode* arguments) {
   // +2 for implicit receiver and construction phase arguments.
   GrowableArray<const Object*> arg_values(arguments->length() + 2);
   Instance& instance = Instance::Handle();
   if (!constructor.IsFactory()) {
     instance = Instance::New(type_class);
     if (!type_arguments.IsNull()) {
@@ skipping 10 matching lines @@
     ASSERT(type_arguments.IsZoneHandle());
     arg_values.Add(&type_arguments);
   }
   for (int i = 0; i < arguments->length(); i++) {
     AstNode* arg = arguments->NodeAt(i);
     // Arguments have been evaluated to a literal value already.
     ASSERT(arg->IsLiteralNode());
     arg_values.Add(&arg->AsLiteralNode()->literal());
   }
   const Array& opt_arg_names = arguments->names();
-  const Instance& result = Instance::Handle(
+  const Object& result = Object::Handle(
       DartEntry::InvokeStatic(constructor, arg_values, opt_arg_names));
-  if (result.IsUnhandledException()) {
-    instance = result.raw();
+  if (result.IsError()) {
+      if (result.IsUnhandledException()) {
+        return result.raw();
+      } else {
+        Error& error = Error::Handle();
+        error ^= result.raw();
+        Isolate::Current()->long_jump_base()->Jump(1, error);
+        UNREACHABLE();
+        return Object::null();
+      }
   } else {
     if (constructor.IsFactory()) {
       // The factory method returns the allocated object.
-      instance = result.raw();
+      instance ^= result.raw();
     }
     if (!instance.IsNull()) {
       instance ^= instance.Canonicalize();
     }
+    return instance.raw();
   }
-  return instance.raw();
 }
 
 
 // Do a lookup for the identifier in the block scope and the class scope
 // return true if the identifier is found, false otherwise.
 // If node is non NULL return an AST node corresponding to the identifier.
 bool Parser::ResolveIdentInLocalScope(intptr_t ident_pos,
                                       const String &ident,
                                       AstNode** node) {
   TRACE_PARSER("ResolveIdentInLocalScope");
@@ skipping 601 matching lines @@
     const Class& immutable_map_class =
         Class::Handle(LookupImplClass(immutable_map_class_name));
     ASSERT(!immutable_map_class.IsNull());
     ArgumentListNode* constr_args = new ArgumentListNode(token_index_);
     constr_args->Add(new LiteralNode(literal_pos, key_value_array));
     const String& constr_name =
         String::Handle(String::NewSymbol(kImmutableMapConstructorName));
     const Function& map_constr = Function::ZoneHandle(
         immutable_map_class.LookupConstructor(constr_name));
     ASSERT(!map_constr.IsNull());
-    const Instance& const_instance = Instance::ZoneHandle(
+    const Object& constructor_result = Object::Handle(
         EvaluateConstConstructorCall(immutable_map_class,
                                      map_type_arguments,
                                      map_constr,
                                      constr_args));
-    if (const_instance.IsUnhandledException()) {
-      return CreateEvalConstConstructorThrow(literal_pos, const_instance);
+    if (constructor_result.IsUnhandledException()) {
+      return CreateEvalConstConstructorThrow(literal_pos, constructor_result);
     } else {
+      Instance& const_instance = Instance::ZoneHandle();
+      const_instance ^= constructor_result.raw();
       return new LiteralNode(literal_pos, const_instance);
     }
   } else {
     // Factory call at runtime.
     String& map_literal_factory_class_name = String::Handle(
         String::NewSymbol(kMapLiteralFactoryClassName));
     const Class& map_literal_factory_class =
         Class::Handle(LookupCoreClass(map_literal_factory_class_name));
     ASSERT(!map_literal_factory_class.IsNull());
     const String& map_literal_factory_name =
@@ skipping 220 matching lines @@
   }
 
   type_arguments ^= type_arguments.Canonicalize();
   // Make the constructor call.
   AstNode* new_object = NULL;
   if (is_const) {
     if (!constructor.is_const()) {
       ErrorMsg("'const' requires const constructor: '%s'",
           String::Handle(constructor.name()).ToCString());
     }
-    const Instance& const_instance = Instance::ZoneHandle(
+    const Object& constructor_result = Object::Handle(
         EvaluateConstConstructorCall(constructor_class,
                                      type_arguments,
                                      constructor,
                                      arguments));
-    if (const_instance.IsUnhandledException()) {
-      new_object = CreateEvalConstConstructorThrow(new_pos, const_instance);
+    if (constructor_result.IsUnhandledException()) {
+      new_object = CreateEvalConstConstructorThrow(new_pos, constructor_result);
     } else {
+      Instance& const_instance = Instance::ZoneHandle();
+      const_instance ^= constructor_result.raw();
       new_object = new LiteralNode(new_pos, const_instance);
     }
   } else {
     CheckFunctionIsCallable(new_pos, constructor);
     CheckConstructorCallTypeArguments(new_pos, constructor, type_arguments);
     if (!type_arguments.IsNull() &&
         !type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureReceiver();
@@ skipping 188 matching lines @@
     return expr->AsLiteralNode()->literal();
   } else {
     ASSERT(expr->EvalConstExpr() != NULL);
     ReturnNode* ret = new ReturnNode(expr->token_index(), expr);
     // Compile time constant expressions cannot reference anything from a
     // local scope.
     LocalScope* empty_scope = new LocalScope(NULL, 0, 0);
     SequenceNode* seq = new SequenceNode(expr->token_index(), empty_scope);
     seq->Add(ret);
 
-    Instance& value = Instance::ZoneHandle(Compiler::ExecuteOnce(seq));
+    Object& result = Object::Handle(Compiler::ExecuteOnce(seq));
+    if (result.IsError()) {
+      // Propagate the compilation error.
+      Error& error = Error::Handle();
+      error ^= result.raw();
+      Isolate::Current()->long_jump_base()->Jump(1, error);
+      UNREACHABLE();
+    }
+    ASSERT(result.IsInstance());
+    Instance& value = Instance::ZoneHandle();
+    value ^= result.raw();
     if (value.IsNull()) {
       value ^= value.Canonicalize();
     }
     return value;
   }
 }
 
 
 void Parser::SkipFunctionLiteral() {
   if (IsIdentifier()) {
@@ skipping 243 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart