It's a compile-time error if a const constructor call fails

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 "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 79 matching lines @@
   for (int i = 0; i < objs.Length(); i++) {
     type ^= objs.At(i);
     a.SetTypeAt(i, type);
   }
   // Cannot canonicalize TypeArgument yet as its types may not have been
   // finalized yet.
   return a.raw();
 }
 
 
-static ThrowNode* GenerateRethrow(intptr_t token_pos, const Object& obj) {
-  const UnhandledException& excp = UnhandledException::Cast(obj);
-  Instance& exception = Instance::ZoneHandle(excp.exception());
-  if (exception.IsNew()) {
-    exception ^= Object::Clone(exception, Heap::kOld);
-  }
-  Instance& stack_trace = Instance::ZoneHandle(excp.stacktrace());
-  if (stack_trace.IsNew()) {
-    stack_trace ^= Object::Clone(stack_trace, Heap::kOld);

[srdjan, 2013/10/24 17:03:32]

Why not Canonicalize instead of Clone?

[hausner, 2013/10/24 17:09:32]

This code goes away, but I don't think canonicalizing stack traces would make
sense. We don't keep them around.

-  }
-  return new ThrowNode(token_pos,
-                       new LiteralNode(token_pos, exception),
-                       new LiteralNode(token_pos, stack_trace));
-}
-
-
 LocalVariable* ParsedFunction::EnsureExpressionTemp() {
   if (!has_expression_temp_var()) {
     LocalVariable* temp =
         new LocalVariable(function_.token_pos(),
                           Symbols::ExprTemp(),
                           Type::ZoneHandle(Type::DynamicType()));
     ASSERT(temp != NULL);
     set_expression_temp_var(temp);
   }
   ASSERT(has_expression_temp_var());
@@ skipping 764 matching lines @@
         ((LookaheadToken(1) == Token::kPERIOD) &&
             (LookaheadToken(3) == Token::kPERIOD) &&
             (LookaheadToken(5) == Token::kLPAREN))) {
       expr = ParseNewOperator(Token::kCONST);
     } else {
       expr = ParsePrimary();
     }
     if (expr->EvalConstExpr() == NULL) {
       ErrorMsg(expr_pos, "expression must be a compile-time constant");
     }
-    const Instance& val = EvaluateConstExpr(expr);
+    const Instance& val = EvaluateConstExpr(expr_pos, expr);
     meta_values.Add(val);
   }
   return Array::MakeArray(meta_values);
 }
 
 
 SequenceNode* Parser::ParseStaticFinalGetter(const Function& func) {
   TRACE_PARSER("ParseStaticFinalGetter");
   ParamList params;
   ASSERT(func.num_fixed_parameters() == 0);  // static.
@@ skipping 1210 matching lines @@
   const intptr_t saved_token_pos = TokenPos();
 
   set_current_class(Class::Handle(field.origin()));
   set_library(Library::Handle(current_class().library()));
   SetScript(Script::Handle(current_class().script()), field.token_pos());
 
   ASSERT(IsIdentifier());
   ConsumeToken();
   ExpectToken(Token::kASSIGN);
   AstNode* init_expr = NULL;
+  intptr_t expr_pos = TokenPos();
   if (field.is_const()) {
     init_expr = ParseConstExpr();
   } else {
     init_expr = ParseExpr(kAllowConst, kConsumeCascades);
     if (init_expr->EvalConstExpr() != NULL) {
       init_expr =
-          new LiteralNode(field.token_pos(), EvaluateConstExpr(init_expr));
+          new LiteralNode(field.token_pos(),
+                          EvaluateConstExpr(expr_pos, init_expr));
     }
   }
   set_current_class(saved_class);
   set_library(saved_library);
   SetScript(saved_script, saved_token_pos);
   return init_expr;
 }
 
 
 void Parser::ParseInitializedInstanceFields(const Class& cls,
@@ skipping 18 matching lines @@
       if (current_class().raw() != field.origin()) {
         init_expr = ParseExternalInitializedField(field);
       } else {
         SetPosition(field.token_pos());
         ASSERT(IsIdentifier());
         ConsumeToken();
         ExpectToken(Token::kASSIGN);
         if (field.is_const()) {
           init_expr = ParseConstExpr();
         } else {
+          intptr_t expr_pos = TokenPos();
           init_expr = ParseExpr(kAllowConst, kConsumeCascades);
           if (init_expr->EvalConstExpr() != NULL) {
             init_expr = new LiteralNode(field.token_pos(),
-                                        EvaluateConstExpr(init_expr));
+                                        EvaluateConstExpr(expr_pos, init_expr));
           }
         }
       }
       ASSERT(init_expr != NULL);
       AstNode* instance = new LoadLocalNode(field.token_pos(), receiver);
       EnsureExpressionTemp();
       AstNode* field_init =
           new StoreInstanceFieldNode(field.token_pos(),
                                      instance,
                                      field,
@@ skipping 5452 matching lines @@
 
 // Evaluates the value of the compile time constant expression
 // and returns a literal node for the value.
 AstNode* Parser::FoldConstExpr(intptr_t expr_pos, AstNode* expr) {
   if (expr->IsLiteralNode()) {
     return expr;
   }
   if (expr->EvalConstExpr() == NULL) {
     ErrorMsg(expr_pos, "expression is not a valid compile-time constant");
   }
-  return new LiteralNode(expr_pos, EvaluateConstExpr(expr));
+  return new LiteralNode(expr_pos, EvaluateConstExpr(expr_pos, expr));
 }
 
 
 LetNode* Parser::PrepareCompoundAssignmentNodes(AstNode** expr) {
   AstNode* node = *expr;
   intptr_t token_pos = node->token_pos();
   LetNode* result = new LetNode(token_pos);
   if (node->IsLoadIndexedNode()) {
     LoadIndexedNode* load_indexed = node->AsLoadIndexedNode();
     AstNode* array = load_indexed->array();
@@ skipping 1902 matching lines @@
     const Function& map_constr =
         Function::ZoneHandle(immutable_map_class.LookupConstructor(
             Library::PrivateCoreLibName(Symbols::ImmutableMapConstructor())));
     ASSERT(!map_constr.IsNull());
     const Object& constructor_result = Object::Handle(
         EvaluateConstConstructorCall(immutable_map_class,
                                      map_type_arguments,
                                      map_constr,
                                      constr_args));
     if (constructor_result.IsUnhandledException()) {
-      return GenerateRethrow(literal_pos, constructor_result);
+      AppendErrorMsg(Error::Cast(constructor_result),
+                     literal_pos,
+                     "error executing const Map constructor");
     } else {
       const Instance& const_instance = Instance::Cast(constructor_result);
       return new LiteralNode(literal_pos,
                              Instance::ZoneHandle(const_instance.raw()));
     }
   } else {
     // Factory call at runtime.
     const Class& factory_class =
         Class::Handle(Library::LookupCoreClass(Symbols::Map()));
     ASSERT(!factory_class.IsNull());
@@ skipping 27 matching lines @@
     ArrayNode* kv_pairs = new ArrayNode(
         TokenPos(),
         Type::ZoneHandle(Type::ArrayType()),
         kv_pairs_list);
     factory_param->Add(kv_pairs);
     return CreateConstructorCallNode(literal_pos,
                                      factory_type_args,
                                      factory_method,
                                      factory_param);
   }
+  UNREACHABLE();
+  return NULL;
 }
 
 
 AstNode* Parser::ParseCompoundLiteral() {
   TRACE_PARSER("ParseCompoundLiteral");
   bool is_const = false;
   if (CurrentToken() == Token::kCONST) {
     is_const = true;
     ConsumeToken();
   }
@@ skipping 45 matching lines @@
       symbol_pos, String::ZoneHandle(Symbols::New(symbol))));
   const Function& constr = Function::ZoneHandle(
       symbol_class.LookupConstructor(Symbols::SymbolCtor()));
   ASSERT(!constr.IsNull());
   const Object& result = Object::Handle(
       EvaluateConstConstructorCall(symbol_class,
                                    TypeArguments::Handle(),
                                    constr,
                                    constr_args));
   if (result.IsUnhandledException()) {
-    return GenerateRethrow(symbol_pos, result);
+    AppendErrorMsg(Error::Cast(result),
+                   symbol_pos,
+                   "error executing const Symbol constructor");
   }
   const Instance& instance = Instance::Cast(result);
   return new LiteralNode(symbol_pos, Instance::ZoneHandle(instance.raw()));
 }
 
 
 static String& BuildConstructorName(const String& type_class_name,
                                     const String* named_constructor) {
   // By convention, the static function implementing a named constructor 'C'
   // for class 'A' is labeled 'A.C', and the static function implementing the
@@ skipping 217 matching lines @@
       ErrorMsg("non-const constructor '%s' cannot be used in "
                "const object creation",
                external_constructor_name.ToCString());
     }
     const Object& constructor_result = Object::Handle(
         EvaluateConstConstructorCall(type_class,
                                      type_arguments,
                                      constructor,
                                      arguments));
     if (constructor_result.IsUnhandledException()) {
-      new_object = GenerateRethrow(new_pos, constructor_result);
+      // It's a compile-time error if invocation of a const constructor
+      // call fails.
+      AppendErrorMsg(Error::Cast(constructor_result),
+                     new_pos,
+                     "error while evaluating const constructor");
     } else {
       const Instance& const_instance = Instance::Cast(constructor_result);
       new_object = new LiteralNode(new_pos,
                                    Instance::ZoneHandle(const_instance.raw()));
       if (!type_bound.IsNull()) {
         ASSERT(!type_bound.IsMalformed());
         Error& malformed_error = Error::Handle();
         ASSERT(!is_top_level_);  // We cannot check unresolved types.
         if (!const_instance.IsInstanceOf(type_bound,
                                          TypeArguments::Handle(),
@@ skipping 116 matching lines @@
       // a constant or not. Only strings, numbers, booleans and null values
       // are allowed in compile time const interpolations.
       if (is_compiletime_const) {
         const Object* const_expr = expr->EvalConstExpr();
         if ((const_expr != NULL) &&
             (const_expr->IsNumber() ||
             const_expr->IsString() ||
             const_expr->IsBool() ||
             const_expr->IsNull())) {
           // Change expr into a literal.
-          expr = new LiteralNode(expr_pos, EvaluateConstExpr(expr));
+          expr = new LiteralNode(expr_pos, EvaluateConstExpr(expr_pos, expr));
         } else {
           is_compiletime_const = false;
         }
       }
       values_list.Add(expr);
     }
   }
   if (is_compiletime_const) {
     if (has_interpolation) {
       primary = new LiteralNode(literal_start, Interpolate(values_list));
@@ skipping 177 matching lines @@
     }
   } else {
     UnexpectedToken();
   }
   return primary;
 }
 
 
 // Evaluate expression in expr and return the value. The expression must
 // be a compile time constant.
-const Instance& Parser::EvaluateConstExpr(AstNode* expr) {
+const Instance& Parser::EvaluateConstExpr(intptr_t expr_pos, AstNode* expr) {
   if (expr->IsLiteralNode()) {
     return expr->AsLiteralNode()->literal();
   } else if (expr->IsLoadLocalNode() &&
       expr->AsLoadLocalNode()->local().IsConst()) {
     return *expr->AsLoadLocalNode()->local().ConstValue();
   } else {
     ASSERT(expr->EvalConstExpr() != NULL);
     ReturnNode* ret = new ReturnNode(expr->token_pos(), 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_pos(), empty_scope);
     seq->Add(ret);
 
     Object& result = Object::Handle(Compiler::ExecuteOnce(seq));
     if (result.IsError()) {
-      // Propagate the compilation error.
-      isolate()->long_jump_base()->Jump(1, Error::Cast(result));
-      UNREACHABLE();
+      AppendErrorMsg(Error::Cast(result),
+                     expr_pos,
+                     "error evaluating constant expression");
     }
     ASSERT(result.IsInstance());
     Instance& value = Instance::ZoneHandle();
     value ^= result.raw();
     value = TryCanonicalize(value, TokenPos());
     return value;
   }
 }
 
 
@@ skipping 320 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart