Make safe points in generated code invisible to the debugger

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 "platform/utils.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 1139 matching lines @@
 
 
 // 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");
   ParamList params;
   // func.token_pos() points to the name of the field.
-  intptr_t ident_pos = func.token_pos();
+  const intptr_t ident_pos = func.token_pos();
   ASSERT(current_class().raw() == func.Owner());
   params.AddReceiver(ReceiverType(current_class()), ident_pos);
   ASSERT(func.num_fixed_parameters() == 1);  // receiver.
   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);
 
   // Receiver is local 0.
   LocalVariable* receiver = current_block_->scope->VariableAt(0);
   LoadLocalNode* load_receiver = new LoadLocalNode(ident_pos, receiver);
   ASSERT(IsIdentifier());
   const String& field_name = *CurrentLiteral();
   const Class& field_class = Class::Handle(func.Owner());
   const Field& field =
       Field::ZoneHandle(field_class.LookupInstanceField(field_name));
 
   LoadInstanceFieldNode* load_field =
       new LoadInstanceFieldNode(ident_pos, load_receiver, field);
 
-  ReturnNode* return_node = new ReturnNode(ident_pos, load_field);
+  ReturnNode* return_node =
+      new ReturnNode(Scanner::kDummyTokenIndex, load_field);

[regis, 2014/01/21 20:11:40]

A comment indicating why it is important to pass a dummy token pos would be
useful for code maintenance. Or maybe an alias of Scanner::kDummyTokenIndex with
a meaningful name would work too.

   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 // Create AstNodes for an implicit instance setter method:
 //   LoadLocalNode 0 ('this')
 //   LoadLocalNode 1 ('value')
 //   SetInstanceField (field_name);
 //   ReturnNode (void);
 SequenceNode* Parser::ParseInstanceSetter(const Function& func) {
   TRACE_PARSER("ParseInstanceSetter");
   // func.token_pos() points to the name of the field.
-  intptr_t ident_pos = func.token_pos();
+  const intptr_t ident_pos = func.token_pos();
   const String& field_name = *CurrentLiteral();
   const Class& field_class = Class::ZoneHandle(func.Owner());
   const Field& field =
       Field::ZoneHandle(field_class.LookupInstanceField(field_name));
   const AbstractType& field_type = AbstractType::ZoneHandle(field.type());
 
   ParamList params;
   ASSERT(current_class().raw() == func.Owner());
   params.AddReceiver(ReceiverType(current_class()), ident_pos);
   params.AddFinalParameter(ident_pos,
                            &Symbols::Value(),
                            &field_type);
   ASSERT(func.num_fixed_parameters() == 2);  // receiver, value.
   ASSERT(!func.HasOptionalParameters());
   ASSERT(AbstractType::Handle(func.result_type()).IsVoidType());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   LoadLocalNode* receiver =
       new LoadLocalNode(ident_pos, current_block_->scope->VariableAt(0));
   LoadLocalNode* value =
       new LoadLocalNode(ident_pos, current_block_->scope->VariableAt(1));
 
   EnsureExpressionTemp();
   StoreInstanceFieldNode* store_field =
       new StoreInstanceFieldNode(ident_pos, receiver, field, value);
   current_block_->statements->Add(store_field);
-  current_block_->statements->Add(new ReturnNode(ident_pos));
+  current_block_->statements->Add(new ReturnNode(Scanner::kDummyTokenIndex));

[regis, 2014/01/21 20:11:40]

ditto

   return CloseBlock();
 }
 
 
 SequenceNode* Parser::ParseMethodExtractor(const Function& func) {
   TRACE_PARSER("ParseMethodExtractor");
   ParamList params;
 
   const intptr_t ident_pos = func.token_pos();
+  const intptr_t invisible_pos = Scanner::kDummyTokenIndex;

[regis, 2014/01/21 20:11:40]

Would be unnecessary if you declare an alias of Scanner::kDummyTokenIndex as
suggested above.

   ASSERT(func.token_pos() == 0);
   ASSERT(current_class().raw() == func.Owner());
   params.AddReceiver(ReceiverType(current_class()), ident_pos);
   ASSERT(func.num_fixed_parameters() == 1);  // Receiver.
   ASSERT(!func.HasOptionalParameters());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   // Receiver is local 0.
   LocalVariable* receiver = current_block_->scope->VariableAt(0);
   LoadLocalNode* load_receiver = new LoadLocalNode(ident_pos, receiver);
 
   ClosureNode* closure = new ClosureNode(
       ident_pos,
       Function::ZoneHandle(func.extracted_method_closure()),
       load_receiver,
       NULL);
 
-  ReturnNode* return_node = new ReturnNode(ident_pos, closure);
+  ReturnNode* return_node = new ReturnNode(invisible_pos, closure);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 void Parser::BuildDispatcherScope(const Function& func,
                                   const ArgumentsDescriptor& desc,
                                   Array& default_values) {
   ParamList params;
   // Receiver first.
@@ skipping 764 matching lines @@
       // No function or field exists of the specified field_name.
       // Emit a StaticGetterNode anyway, so that noSuchMethod gets called.
     }
   }
   return new StaticGetterNode(
       field_pos, implicit_argument, true, super_class, field_name);
 }
 
 
 void Parser::GenerateSuperConstructorCall(const Class& cls,
+                                          intptr_t supercall_pos,
                                           LocalVariable* receiver,
                                           ArgumentListNode* forwarding_args) {
-  const intptr_t supercall_pos = TokenPos();
   const Class& super_class = Class::Handle(cls.SuperClass());
   // Omit the implicit super() if there is no super class (i.e.
   // we're not compiling class Object), or if the super class is an
   // artificially generated "wrapper class" that has no constructor.
   if (super_class.IsNull() ||
       (super_class.num_native_fields() > 0 &&
        Class::Handle(super_class.SuperClass()).IsObjectClass())) {
     return;
   }
   String& super_ctor_name = String::Handle(super_class.Name());
@@ skipping 298 matching lines @@
         super_init_seen = true;
       } else {
         init_statement = ParseInitializer(cls, receiver, initialized_fields);
       }
       current_block_->statements->Add(init_statement);
     } while (CurrentToken() == Token::kCOMMA);
   }
   if (!super_init_seen) {
     // Generate implicit super() if we haven't seen an explicit super call
     // or constructor redirection.
-    GenerateSuperConstructorCall(cls, receiver, NULL);
+    GenerateSuperConstructorCall(cls, TokenPos(), receiver, NULL);
   }
   CheckFieldsInitialized(cls);
 }
 
 
 void Parser::ParseConstructorRedirection(const Class& cls,
                                          LocalVariable* receiver) {
   TRACE_PARSER("ParseConstructorRedirection");
   ExpectToken(Token::kCOLON);
   ASSERT(CurrentToken() == Token::kTHIS);
@@ skipping 38 matching lines @@
   }
   current_block_->statements->Add(
       new StaticCallNode(call_pos, redirect_ctor, arguments));
 }
 
 
 SequenceNode* Parser::MakeImplicitConstructor(const Function& func) {
   ASSERT(func.IsConstructor());
   ASSERT(func.Owner() == current_class().raw());
   const intptr_t ctor_pos = TokenPos();
+  const intptr_t dummy_pos = Scanner::kDummyTokenIndex;

[regis, 2014/01/21 20:11:40]

ditto

   OpenFunctionBlock(func);
 
   LocalVariable* receiver = new LocalVariable(
-      ctor_pos, Symbols::This(), *ReceiverType(current_class()));
+      dummy_pos, Symbols::This(), *ReceiverType(current_class()));
   current_block_->scope->AddVariable(receiver);
 
   LocalVariable* phase_parameter = new LocalVariable(
-      ctor_pos, Symbols::PhaseParameter(), Type::ZoneHandle(Type::SmiType()));
+      dummy_pos, Symbols::PhaseParameter(), Type::ZoneHandle(Type::SmiType()));
   current_block_->scope->AddVariable(phase_parameter);
 
   // Parse expressions of instance fields that have an explicit
   // initializer expression.
   // The receiver must not be visible to field initializer expressions.
   receiver->set_invisible(true);
   GrowableArray<Field*> initialized_fields;
   ParseInitializedInstanceFields(
       current_class(), receiver, &initialized_fields);
   receiver->set_invisible(false);
@@ skipping 15 matching lines @@
     // whether optional parameters are even allowed in this situation.
     // TODO(hausner): Remove this limitation if the language spec indeed
     // allows optional parameters.
     if (func.HasOptionalParameters()) {
       ErrorMsg(ctor_pos,
                "forwarding constructors must not have optional parameters");
     }
 
     // Prepare user-defined arguments to be forwarded to super call.
     // The first user-defined argument is at position 2.
-    forwarding_args = new ArgumentListNode(ctor_pos);
+    forwarding_args = new ArgumentListNode(dummy_pos);
     for (int i = 2; i < func.NumParameters(); i++) {
       LocalVariable* param = new LocalVariable(
-          ctor_pos,
+          dummy_pos,
           String::ZoneHandle(func.ParameterNameAt(i)),
           Type::ZoneHandle(Type::DynamicType()));
       current_block_->scope->AddVariable(param);
-      forwarding_args->Add(new LoadLocalNode(ctor_pos, param));
+      forwarding_args->Add(new LoadLocalNode(dummy_pos, param));
     }
   }
 
-  GenerateSuperConstructorCall(current_class(), receiver, forwarding_args);
+  GenerateSuperConstructorCall(current_class(),
+                               dummy_pos,
+                               receiver,
+                               forwarding_args);
   CheckFieldsInitialized(current_class());
 
   // Empty constructor body.
+  current_block_->statements->Add(new ReturnNode(dummy_pos));
   SequenceNode* statements = CloseBlock();
   return statements;
 }
 
 
 void Parser::CheckRecursiveInvocation() {
   const GrowableObjectArray& pending_functions =
       GrowableObjectArray::Handle(
           isolate()->object_store()->pending_functions());
   for (int i = 0; i < pending_functions.Length(); i++) {
@@ skipping 139 matching lines @@
   }
 
   SequenceNode* init_statements = CloseBlock();
   if (is_redirecting_constructor) {
     // A redirecting super constructor simply passes the phase parameter on to
     // the target which executes the corresponding phase.
     current_block_->statements->Add(init_statements);
   } else if (init_statements->length() > 0) {
     // Generate guard around the initializer code.
     LocalVariable* phase_param = LookupPhaseParameter();
-    AstNode* phase_value = new LoadLocalNode(TokenPos(), phase_param);
+    AstNode* phase_value = new
+        LoadLocalNode(Scanner::kDummyTokenIndex, phase_param);
     AstNode* phase_check = new BinaryOpNode(
-        TokenPos(), Token::kBIT_AND, phase_value,
-        new LiteralNode(TokenPos(),
+        Scanner::kDummyTokenIndex, Token::kBIT_AND, phase_value,
+        new LiteralNode(Scanner::kDummyTokenIndex,
                         Smi::ZoneHandle(Smi::New(Function::kCtorPhaseInit))));
     AstNode* comparison =
-        new ComparisonNode(TokenPos(), Token::kNE_STRICT,
+        new ComparisonNode(Scanner::kDummyTokenIndex,
+                           Token::kNE_STRICT,
                            phase_check,
                            new LiteralNode(TokenPos(),
                                            Smi::ZoneHandle(Smi::New(0))));
     AstNode* guarded_init_statements =
-        new IfNode(TokenPos(), comparison, init_statements, NULL);
+        new IfNode(Scanner::kDummyTokenIndex,
+                   comparison,
+                   init_statements,
+                   NULL);
     current_block_->statements->Add(guarded_init_statements);
   }
 
   // Parsing of initializers done. Now we parse the constructor body
   // and add the implicit super call to the super constructor's body
   // if necessary.
   StaticCallNode* super_call = NULL;
   // Look for the super initializer call in the sequence of initializer
   // statements. If it exists and is not the last initializer statement,
   // we need to create an implicit super call to the super constructor's
@@ skipping 94 matching lines @@
     // Some constructors have no function body.
     ConsumeToken();
   } else {
     UnexpectedToken();
   }
 
   SequenceNode* ctor_block = CloseBlock();
   if (ctor_block->length() > 0) {
     // Generate guard around the constructor body code.
     LocalVariable* phase_param = LookupPhaseParameter();
-    AstNode* phase_value = new LoadLocalNode(body_pos, phase_param);
+    AstNode* phase_value =
+        new LoadLocalNode(Scanner::kDummyTokenIndex, phase_param);
     AstNode* phase_check =
-        new BinaryOpNode(body_pos, Token::kBIT_AND,
+        new BinaryOpNode(Scanner::kDummyTokenIndex, Token::kBIT_AND,
             phase_value,
-            new LiteralNode(body_pos,
+            new LiteralNode(Scanner::kDummyTokenIndex,
                 Smi::ZoneHandle(Smi::New(Function::kCtorPhaseBody))));
     AstNode* comparison =
-       new ComparisonNode(body_pos, Token::kNE_STRICT,
-                         phase_check,
-                         new LiteralNode(body_pos,
-                                         Smi::ZoneHandle(Smi::New(0))));
+        new ComparisonNode(Scanner::kDummyTokenIndex,
+                           Token::kNE_STRICT,
+                           phase_check,
+                           new LiteralNode(body_pos,
+                                           Smi::ZoneHandle(Smi::New(0))));
     AstNode* guarded_block_statements =
-        new IfNode(body_pos, comparison, ctor_block, NULL);
+        new IfNode(Scanner::kDummyTokenIndex, comparison, ctor_block, NULL);
     current_block_->statements->Add(guarded_block_statements);
   }
-
+  current_block_->statements->Add(new ReturnNode(func.end_token_pos()));
   SequenceNode* statements = CloseBlock();
   return statements;
 }
 
 
 // Parser is at the opening parenthesis of the formal parameter
 // declaration of the function or constructor.
 // Parse the formal parameters and code.
 SequenceNode* Parser::ParseFunc(const Function& func,
                                 Array& default_parameter_values) {
@@ skipping 147 matching lines @@
   func.set_end_token_pos(end_token_pos);
   SequenceNode* body = CloseBlock();
   current_block_->statements->Add(body);
   innermost_function_ = saved_innermost_function.raw();
   last_used_try_index_ = saved_try_index;
   return CloseBlock();
 }
 
 
 void Parser::AddEqualityNullCheck() {
-  const intptr_t token_pos = TokenPos();
+  const intptr_t dummy_pos = Scanner::kDummyTokenIndex;
   AstNode* argument =
-      new LoadLocalNode(token_pos,
+      new LoadLocalNode(dummy_pos,
                         current_block_->scope->parent()->VariableAt(1));
   LiteralNode* null_operand =
-      new LiteralNode(token_pos, Instance::ZoneHandle());
-  ComparisonNode* check_arg = new ComparisonNode(token_pos,
+      new LiteralNode(dummy_pos, Instance::ZoneHandle());
+  ComparisonNode* check_arg = new ComparisonNode(dummy_pos,
                                                  Token::kEQ_STRICT,
                                                  argument,
                                                  null_operand);
-  ComparisonNode* result = new ComparisonNode(token_pos,
+  ComparisonNode* result = new ComparisonNode(dummy_pos,
                                               Token::kEQ_STRICT,
-                                              LoadReceiver(token_pos),
+                                              LoadReceiver(dummy_pos),
                                               null_operand);
-  SequenceNode* arg_is_null = new SequenceNode(token_pos, NULL);
-  arg_is_null->Add(new ReturnNode(token_pos, result));
-  IfNode* if_arg_null = new IfNode(token_pos,
+  SequenceNode* arg_is_null = new SequenceNode(dummy_pos, NULL);
+  arg_is_null->Add(new ReturnNode(dummy_pos, result));
+  IfNode* if_arg_null = new IfNode(dummy_pos,
                                    check_arg,
                                    arg_is_null,
                                    NULL);
   current_block_->statements->Add(if_arg_null);
 }
 
 
 void Parser::SkipIf(Token::Kind token) {
   if (CurrentToken() == token) {
     ConsumeToken();
@@ skipping 7801 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart