Report NullPointerException when we try to construct a regular expression

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 84 matching lines @@
 
 static RawTypeArray* NewTypeArray(const GrowableArray<Type*>& objs) {
   TypeArray& a = TypeArray::Handle(TypeArray::New(objs.length()));
   for (int i = 0; i < objs.length(); i++) {
     a.SetTypeAt(i, *objs[i]);
   }
   return a.raw();
 }
 
 
+static ThrowNode* CreateEvalConstConstructorThrow(intptr_t token_pos,
+                                                  const Instance& instance) {
+  UnhandledException& excp = UnhandledException::Handle();
+  excp ^= instance.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)
     : parent(outer_block), scope(local_scope), statements(seq) {
     ASSERT(scope != NULL);
     ASSERT(statements != NULL);
   }
   Block* parent;  // Enclosing block, or NULL if outermost.
   LocalScope* scope;
   SequenceNode* statements;
 };
@@ skipping 5708 matching lines @@
   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(
       DartEntry::InvokeStatic(constructor, arg_values, opt_arg_names));
   if (result.IsUnhandledException()) {
-    ErrorMsg("Exception thrown in EvaluateConstConstructorCall");
-  }
-  if (constructor.IsFactory()) {
-    // The factory method returns the allocated object.
     instance = result.raw();
-  }
-  if (!instance.IsNull()) {
-    instance ^= instance.Canonicalize();
+  } else {
+    if (constructor.IsFactory()) {
+      // The factory method returns the allocated object.
+      instance = result.raw();
+    }
+    if (!instance.IsNull()) {
+      instance ^= instance.Canonicalize();
+    }
   }
   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,
@@ skipping 472 matching lines @@
     key_value_array.MakeImmutable();
 
     // Construct the map object.
     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(
         map_class.LookupConstructor(constr_name));
     ASSERT(!map_constr.IsNull());
-    return new LiteralNode(literal_pos, Instance::ZoneHandle(
-        EvaluateConstConstructorCall(
-            map_class, map_type_arguments, map_constr, constr_args)));
+    const Instance& const_instance = Instance::ZoneHandle(
+        EvaluateConstConstructorCall(map_class,
+                                     map_type_arguments,
+                                     map_constr,
+                                     constr_args));
+    if (const_instance.IsUnhandledException()) {
+      return CreateEvalConstConstructorThrow(literal_pos, const_instance);
+    } else {
+      return new LiteralNode(literal_pos, const_instance);
+    }
   } else {
     // Static call at runtime.
     const String& static_factory_name =
         String::Handle(String::NewSymbol(kMutableMapFromLiteralName));
     const Function& static_factory = Function::ZoneHandle(
         map_class.LookupStaticFunction(static_factory_name));
     ASSERT(!static_factory.IsNull());
     if (!map_type_arguments.IsNull() &&
         !map_type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
@@ skipping 203 matching lines @@
              String::Handle(type_class.Name()).ToCString());
   }
 
   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(
-        EvaluateConstConstructorCall(
-            type_class, type_arguments, constructor, arguments));
-    new_object = new LiteralNode(new_pos, const_instance);
+        EvaluateConstConstructorCall(type_class,
+                                     type_arguments,
+                                     constructor,
+                                     arguments));
+    if (const_instance.IsUnhandledException()) {
+      new_object = CreateEvalConstConstructorThrow(new_pos, const_instance);
+    } else {
+      new_object = new LiteralNode(new_pos, const_instance);
+    }
   } else {
     CheckFunctionIsCallable(new_pos, constructor);
     if (!type_arguments.IsNull() &&
         !type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureReceiver();
     }
     new_object = new ConstructorCallNode(
         new_pos, type_arguments, constructor, arguments);
@@ skipping 432 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart