Add missing type checks for top level static initializers (issue 1980 and

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 82 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* CreateEvalConstConstructorThrow(intptr_t token_pos,
-                                                  const Object& obj) {
+static ThrowNode* GenerateRethrow(intptr_t token_pos, const Object& obj) {
   UnhandledException& excp = UnhandledException::Handle();
   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));
 }
 
 
@@ skipping 5035 matching lines @@
       InlinedFinallyNode* node = new InlinedFinallyNode(finally_pos,
                                                         finally_block,
                                                         *context_var);
       AddFinallyBlockToNode(node_to_inline, node);
       node_index += 1;
       node_to_inline = inner_try_block->GetNodeToInlineFinally(node_index);
       token_index_ = finally_pos;
     }
     if (!generic_catch_seen) {
       // No generic catch handler exists so execute this finally block
-      // before rethrowing the excetion.
+      // before rethrowing the exception.
       finally_block = ParseFinallyBlock();
       catch_handler_list->Add(finally_block);
       token_index_ = finally_pos;
     }
     finally_block = ParseFinallyBlock();
   } else {
     if (!catch_seen) {
       ErrorMsg("'catch' or 'finally' expected");
     }
   }
@@ skipping 1001 matching lines @@
   } else {
     access = CallGetter(call_pos, receiver, field_name);
   }
   return access;
 }
 
 
 AstNode* Parser::GenerateStaticFieldLookup(const Field& field,
                                            intptr_t ident_pos) {
   // Run static field initializer first if necessary.
-  RunStaticFieldInitializer(field);
-
-  // Access the field
+  // May return an exception throwing ast node.
+  AstNode* throw_exception = RunStaticFieldInitializer(field);
+  if (throw_exception != NULL) {
+    return throw_exception;
+  }
+  // Access the field.
   if (field.is_final()) {
     return new LiteralNode(ident_pos, Instance::ZoneHandle(field.value()));
   } else {
     return new LoadStaticFieldNode(ident_pos,
                                    Field::ZoneHandle(field.raw()));
   }
 }
 
 
 AstNode* Parser::ParseStaticFieldAccess(const Class& cls,
@@ skipping 446 matching lines @@
   while (outer_function.IsLocalFunction()) {
     outer_function = outer_function.parent_function();
   }
   if (outer_function.IsFactory() || !outer_function.is_static()) {
     return current_class().NumTypeParameters() > 0;
   }
   return false;
 }
 
 
-void Parser::RunStaticFieldInitializer(const Field& field) {
+// Returns null on success.
+// Returns a throw node if evaluation of the static initializer results in an
+// unhandled exception.
+AstNode* Parser::RunStaticFieldInitializer(const Field& field) {
   ASSERT(field.is_static());
   const Instance& value = Instance::Handle(field.value());
   if (value.raw() == Object::transition_sentinel()) {
     ErrorMsg("circular dependency while initializing static field '%s'",
              String::Handle(field.name()).ToCString());
 
   } else if (value.raw() == Object::sentinel()) {
     // This field has not been referenced yet and thus the value has
     // not been evaluated. Call the static getter method to evaluate
     // the expression and canonicalize the value.
@@ skipping 10 matching lines @@
         Function::Handle(Resolver::ResolveStatic(cls,
                                                  getter_name,
                                                  kNumArguments,
                                                  kNoArgumentNames,
                                                  Resolver::kIsQualified));
     ASSERT(!func.IsNull());
     ASSERT(func.kind() == RawFunction::kConstImplicitGetter);
     Object& const_value = Object::Handle(
         DartEntry::InvokeStatic(func, arguments, kNoArgumentNames));
     if (const_value.IsError()) {
+      Error& error = Error::Handle();
+      error ^= const_value.raw();
       if (const_value.IsUnhandledException()) {
-        ErrorMsg("exception thrown in Parser::RunStaticFieldInitializer");
+        // It is a compile-time error if evaluation of a compile-time constant
+        // would raise an exception.
+        if (field.is_final()) {
+          AppendErrorMsg(error, token_index_,
+                         "error initializing final field '%s'",
+                         String::Handle(field.name()).ToCString());
+        } else {
+          return GenerateRethrow(token_index_, const_value);
+        }
       } else {
-        Error& error = Error::Handle();
-        error ^= const_value.raw();
         Isolate::Current()->long_jump_base()->Jump(1, error);
       }
     }
     ASSERT(const_value.IsNull() || const_value.IsInstance());
     Instance& instance = Instance::Handle();
     instance ^= const_value.raw();
     if (!instance.IsNull()) {
       instance ^= instance.Canonicalize();
     }
     field.set_value(instance);
   }
+  return NULL;
 }
 
 
 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);
@@ skipping 691 matching lines @@
         String::Handle(String::NewSymbol(kImmutableMapConstructorName));
     const Function& map_constr = Function::ZoneHandle(
         immutable_map_class.LookupConstructor(constr_name));
     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 CreateEvalConstConstructorThrow(literal_pos, constructor_result);
+      return GenerateRethrow(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 =
@@ skipping 247 matching lines @@
     if (type.IsMalformed()) {
       // Compile the throw of a dynamic type error due to a bound error.
       return ThrowTypeError(type_pos, type);
     }
     const Object& constructor_result = Object::Handle(
         EvaluateConstConstructorCall(constructor_class,
                                      type_arguments,
                                      constructor,
                                      arguments));
     if (constructor_result.IsUnhandledException()) {
-      new_object = CreateEvalConstConstructorThrow(new_pos, constructor_result);
+      new_object = GenerateRethrow(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() &&
@@ skipping 35 matching lines @@
   GrowableArray<const Object*> interpolate_arg;
   interpolate_arg.Add(&value_arr);
   const Array& kNoArgumentNames = Array::Handle();
 
   // Call interpolation function.
   String& concatenated = String::ZoneHandle();
   concatenated ^= DartEntry::InvokeStatic(func,
                                           interpolate_arg,
                                           kNoArgumentNames);
   if (concatenated.IsUnhandledException()) {
+    // TODO(regis): Report
     ErrorMsg("Exception thrown in Parser::Interpolate");
   }
   concatenated = String::NewSymbol(concatenated);
   return concatenated;
 }
 
 
 // A string literal consists of the concatenation of the next n tokens
 // that satisfy the EBNF grammar:
 // literal = kSTRING {{ interpol } kSTRING }
@@ skipping 522 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart