Version 0.8.10.3

dart/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 997 matching lines @@
         ident_pos,
         Token::kEQ_STRICT,
         new LoadStaticFieldNode(ident_pos, field),
         new LiteralNode(ident_pos, Object::sentinel()));
     SequenceNode* initialize_field = new SequenceNode(ident_pos, NULL);
     initialize_field->Add(
         new StoreStaticFieldNode(
             ident_pos,
             field,
             new LiteralNode(ident_pos, Object::transition_sentinel())));
-    // TODO(hausner): If evaluation of the field value throws an exception,
-    // we leave the field value as 'transition_sentinel', which is wrong.
-    // A second reference to the field later throws a circular dependency
-    // exception. The field should instead be set to null after an exception.
-    const String& init_name =
-        String::Handle(Symbols::New(String::Handle(
-        String::Concat(Symbols::InitPrefix(), String::Handle(field.name())))));
+    const String& init_name = String::Handle(
+        Symbols::New(String::Handle(String::Concat(
+            Symbols::InitPrefix(), String::Handle(field.name())))));
     const Function& init_function = Function::ZoneHandle(
         field_class.LookupStaticFunction(init_name));
     ASSERT(!init_function.IsNull());
     ArgumentListNode* arguments = new ArgumentListNode(expr_pos);
     StaticCallNode* init_call =
         new StaticCallNode(expr_pos, init_function, arguments);
+    initialize_field->Add(init_call);
 
-    initialize_field->Add(new StoreStaticFieldNode(ident_pos,
-                                                   field,
-                                                   init_call));
     AstNode* uninitialized_check =
         new IfNode(ident_pos, compare_uninitialized, initialize_field, NULL);
     current_block_->statements->Add(uninitialized_check);
 
     // Generate code returning the field value.
     ReturnNode* return_node =
         new ReturnNode(ident_pos,
                        new LoadStaticFieldNode(ident_pos, field));
     current_block_->statements->Add(return_node);
   }
   return CloseBlock();
 }
 
 
 SequenceNode* Parser::ParseStaticInitializer(const Function& func) {
   TRACE_PARSER("ParseStaticInitializer");
   ParamList params;
   ASSERT(func.num_fixed_parameters() == 0);  // static.
   ASSERT(!func.HasOptionalParameters());
   ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
-  intptr_t expr_pos = func.token_pos();
+  // Move forward to the start of the initializer expression.
+  ExpectIdentifier("identifier expected");
+  ExpectToken(Token::kASSIGN);
+  intptr_t token_pos = TokenPos();
+
+  // Synthesize a try-catch block to wrap the initializer expression.
+  LocalVariable* context_var =
+      current_block_->scope->LocalLookupVariable(Symbols::SavedTryContextVar());
+  if (context_var == NULL) {
+    context_var = new LocalVariable(token_pos,
+                                    Symbols::SavedTryContextVar(),
+                                    Type::ZoneHandle(Type::DynamicType()));
+    current_block_->scope->AddVariable(context_var);
+  }
+  LocalVariable* catch_excp_var =
+      current_block_->scope->LocalLookupVariable(Symbols::ExceptionVar());
+  if (catch_excp_var == NULL) {
+    catch_excp_var = new LocalVariable(token_pos,
+                                       Symbols::ExceptionVar(),
+                                       Type::ZoneHandle(Type::DynamicType()));
+    current_block_->scope->AddVariable(catch_excp_var);
+  }
+  LocalVariable* catch_trace_var =
+      current_block_->scope->LocalLookupVariable(Symbols::StacktraceVar());
+  if (catch_trace_var == NULL) {
+    catch_trace_var = new LocalVariable(token_pos,
+                                        Symbols::StacktraceVar(),
+                                        Type::ZoneHandle(Type::DynamicType()));
+    current_block_->scope->AddVariable(catch_trace_var);
+  }
+
+  OpenBlock();  // Start try block.
   AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
-  ReturnNode* return_node = new ReturnNode(expr_pos, expr);
-  current_block_->statements->Add(return_node);
+  const Field& field = Field::ZoneHandle(func.saved_static_field());
+  ASSERT(!field.is_const());
+  StoreStaticFieldNode* store = new StoreStaticFieldNode(field.token_pos(),
+                                                         field,
+                                                         expr);
+  current_block_->statements->Add(store);
+  SequenceNode* try_block = CloseBlock();  // End try block.
+
+  OpenBlock();  // Start catch handler list.
+  SourceLabel* end_catch_label =
+      SourceLabel::New(token_pos, NULL, SourceLabel::kCatch);
+  current_block_->scope->AddLabel(end_catch_label);
+
+  OpenBlock();  // Start catch clause.
+  AstNode* compare_transition_sentinel = new ComparisonNode(
+      token_pos,
+      Token::kEQ_STRICT,
+      new LoadStaticFieldNode(token_pos, field),
+      new LiteralNode(field.token_pos(), Object::transition_sentinel()));
+
+  SequenceNode* store_null = new SequenceNode(token_pos, NULL);
+  store_null->Add(new StoreStaticFieldNode(
+      field.token_pos(),
+      field,
+      new LiteralNode(token_pos, Instance::ZoneHandle())));
+  AstNode* transition_sentinel_check =
+      new IfNode(token_pos, compare_transition_sentinel, store_null, NULL);
+  current_block_->statements->Add(transition_sentinel_check);
+
+  current_block_->statements->Add(
+      new ThrowNode(token_pos,
+                    new LoadLocalNode(token_pos, catch_excp_var),
+                    new LoadLocalNode(token_pos, catch_trace_var)));
+  current_block_->statements->Add(
+      new JumpNode(token_pos, Token::kCONTINUE, end_catch_label));
+  SequenceNode* catch_clause = CloseBlock();  // End catch clause.
+
+  current_block_->statements->Add(catch_clause);
+  SequenceNode* catch_handler_list = CloseBlock();  // End catch handler list.
+  CatchClauseNode* catch_block =
+      new CatchClauseNode(token_pos,
+                          catch_handler_list,
+                          Array::ZoneHandle(Object::empty_array().raw()),
+                          context_var,
+                          catch_excp_var,
+                          catch_trace_var,
+                          CatchClauseNode::kInvalidTryIndex,
+                          false);  // No stack trace needed.
+
+  AstNode* try_catch_node = new TryCatchNode(token_pos,
+                                             try_block,
+                                             end_catch_label,
+                                             context_var,
+                                             catch_block,
+                                             NULL,  // No finally block.
+                                             AllocateTryIndex());
+  current_block_->statements->Add(try_catch_node);
   return CloseBlock();
 }
 
 
 // Create AstNodes for an implicit instance getter method:
 //   LoadLocalNode 0 ('this');
 //   LoadInstanceFieldNode (field_name);
 //   ReturnNode (field's value);
 SequenceNode* Parser::ParseInstanceGetter(const Function& func) {
   TRACE_PARSER("ParseInstanceGetter");
@@ skipping 2226 matching lines @@
   if (field->has_factory) {
     ErrorMsg("keyword 'factory' not allowed in field declaration");
   }
   if (!field->has_static && field->has_const) {
     ErrorMsg(field->name_pos, "instance field may not be 'const'");
   }
   Function& getter = Function::Handle();
   Function& setter = Function::Handle();
   Field& class_field = Field::ZoneHandle();
   Instance& init_value = Instance::Handle();
-  intptr_t expr_pos = -1;
   while (true) {
     bool has_initializer = CurrentToken() == Token::kASSIGN;
     bool has_simple_literal = false;
     if (has_initializer) {
       ConsumeToken();
       init_value = Object::sentinel().raw();
       // For static const fields and static final non-const fields, the
       // initialization expression will be parsed through the
       // kImplicitStaticFinalGetter method invocation/compilation.
       // For instance fields, the expression is parsed when a constructor
       // is compiled.
       // For static const fields and static final non-const fields with very
       // simple initializer expressions (e.g. a literal number or string), we
       // optimize away the kImplicitStaticFinalGetter and initialize the field
       // here. However, the class finalizer will check the value type for
       // assignability once the declared field type can be resolved. If the
       // value is not assignable (assuming checked mode and disregarding actual
       // mode), the field value is reset and a kImplicitStaticFinalGetter is
       // created at finalization time.
 
       if (field->has_static && (field->has_const || field->has_final) &&
           (LookaheadToken(1) == Token::kSEMICOLON)) {
         has_simple_literal = IsSimpleLiteral(*field->type, &init_value);
       }
-      expr_pos = TokenPos();
       SkipExpr();
     } else {
       // Static const and static final fields must have an initializer.
       // Static const fields are implicitly final.
       if (field->has_static && field->has_final) {
         ErrorMsg(field->name_pos,
                  "static %s field '%s' must have an initializer expression",
                  field->has_const ? "const" : "final",
                  field->name->ToCString());
       }
@@ skipping 24 matching lines @@
                                RawFunction::kImplicitStaticFinalGetter,
                                field->has_static,
                                field->has_const,
                                /* is_abstract = */ false,
                                /* is_external = */ false,
                                current_class(),
                                field->name_pos);
         getter.set_result_type(*field->type);
         members->AddFunction(getter);
 
-        // Create initializer function.
-        const Function& init_function = Function::ZoneHandle(
-            Function::NewStaticInitializer(*field->name,
-                                           *field->type,
-                                           current_class(),
-                                           expr_pos));
-        members->AddFunction(init_function);
+        // Create initializer function for non-const fields.
+        if (!class_field.is_const()) {
+          const Function& init_function = Function::ZoneHandle(
+              Function::NewStaticInitializer(class_field));
+          members->AddFunction(init_function);
+        }
       }
     }
 
     // For instance fields, we create implicit getter and setter methods.
     if (!field->has_static) {
       String& getter_name = String::Handle(Field::GetterSymbol(*field->name));
       getter = Function::New(getter_name, RawFunction::kImplicitGetter,
                              field->has_static,
                              field->has_final,
                              /* is_abstract = */ false,
@@ skipping 1089 matching lines @@
     if (metadata_pos >= 0) {
       library_.AddFieldMetadata(field, metadata_pos);
     }
     if (CurrentToken() == Token::kASSIGN) {
       ConsumeToken();
       Instance& field_value = Instance::Handle(Object::sentinel().raw());
       bool has_simple_literal = false;
       if ((is_const || is_final) && (LookaheadToken(1) == Token::kSEMICOLON)) {
         has_simple_literal = IsSimpleLiteral(type, &field_value);
       }
-      const intptr_t expr_pos = TokenPos();
       SkipExpr();
       field.set_value(field_value);
       if (!has_simple_literal) {
         // Create a static final getter.
         String& getter_name = String::Handle(Field::GetterSymbol(var_name));
         getter = Function::New(getter_name,
                                RawFunction::kImplicitStaticFinalGetter,
                                is_static,
                                is_const,
                                /* is_abstract = */ false,
                                /* is_external = */ false,
                                current_class(),
                                name_pos);
         getter.set_result_type(type);
         top_level->functions.Add(getter);
 
         // Create initializer function.
-        const Function& init_function = Function::ZoneHandle(
-            Function::NewStaticInitializer(var_name,
-                                           type,
-                                           current_class(),
-                                           expr_pos));
-        top_level->functions.Add(init_function);
+        if (!field.is_const()) {
+          const Function& init_function = Function::ZoneHandle(
+              Function::NewStaticInitializer(field));
+          top_level->functions.Add(init_function);
+        }
       }
     } else if (is_final) {
       ErrorMsg(name_pos, "missing initializer for final or const variable");
     }
 
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
     } else if (CurrentToken() == Token::kSEMICOLON) {
       ConsumeToken();
       break;
@@ skipping 2205 matching lines @@
   // Now create a label for the end of catch block processing so that we can
   // jump over the catch block code after executing the try block.
   SourceLabel* end_catch_label =
       SourceLabel::New(TokenPos(), NULL, SourceLabel::kCatch);
 
   // Now parse the 'catch' blocks if any and merge all of them into
   // an if-then sequence of the different types specified using the 'is'
   // operator.
   bool catch_seen = false;
   bool generic_catch_seen = false;
-  SequenceNode* catch_handler_list = NULL;
   const intptr_t handler_pos = TokenPos();
   OpenBlock();  // Start the catch block sequence.
   current_block_->scope->AddLabel(end_catch_label);
   const GrowableObjectArray& handler_types =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   bool needs_stacktrace = false;
   while ((CurrentToken() == Token::kCATCH) || IsLiteral("on")) {
     const intptr_t catch_pos = TokenPos();
     CatchParamDesc exception_param;
     CatchParamDesc stack_trace_param;
@@ skipping 103 matching lines @@
       // This catch clause will handle all exceptions. We can safely forget
       // all previous catch clause types.
       handler_types.SetLength(0);
       handler_types.Add(*exception_param.type);
     }
     SequenceNode* catch_clause = CloseBlock();
 
     // Add this individual catch handler to the catch handlers list.
     current_block_->statements->Add(catch_clause);
   }
-  catch_handler_list = CloseBlock();
+  SequenceNode* catch_handler_list = CloseBlock();
   TryBlocks* inner_try_block = PopTryBlock();
   const intptr_t try_index = inner_try_block->try_index();
   TryBlocks* outer_try_block = try_blocks_list_;
   const intptr_t outer_try_index = (outer_try_block != NULL)
       ? outer_try_block->try_index()
       : CatchClauseNode::kInvalidTryIndex;
 
   // Finally parse the 'finally' block.
   SequenceNode* finally_block = NULL;
   if (CurrentToken() == Token::kFINALLY) {
@@ skipping 3782 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart