Introduce is_debuggable state bit on function objects

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/ast_transformer.h"
 #include "vm/bootstrap.h"
@@ skipping 926 matching lines @@
     const Function& fake_function = Function::ZoneHandle(Function::New(
         Symbols::At(),
         RawFunction::kRegularFunction,
         true,  // is_static
         false,  // is_const
         false,  // is_abstract
         false,  // is_external
         false,  // is_native
         cls,
         token_pos));
+    fake_function.set_is_debuggable(false);
     ParsedFunction* parsed_function =
         new ParsedFunction(isolate, fake_function);
     Parser parser(script, parsed_function, token_pos);
     parser.set_current_class(cls);
 
     RawObject* metadata = parser.EvaluateMetadata();
     return metadata;
   } else {
     Error& error = Error::Handle(isolate);
     error = isolate->object_store()->sticky_error();
@@ skipping 118 matching lines @@
                     false,  // !external
                     false,  // !native
                     Class::Handle(field.owner()),
                     field.token_pos()));
   initializer.set_result_type(AbstractType::Handle(isolate, field.type()));
   // Static initializer functions are hidden from the user.
   // Since they are only executed once, we avoid optimizing
   // and inlining them. After the field is initialized, the
   // compiler can eliminate the call to the static initializer.
   initializer.set_is_visible(false);
+  initializer.set_is_debuggable(false);
   initializer.SetIsOptimizable(false);
   initializer.set_is_inlinable(false);
 
   ParsedFunction* parsed_function = new ParsedFunction(isolate, initializer);
   Parser parser(script, parsed_function, field.token_pos());
 
   SequenceNode* body = parser.ParseStaticInitializer();
   parsed_function->SetNodeSequence(body);
   parsed_function->set_default_parameter_values(Object::null_array());
 
@@ skipping 545 matching lines @@
           Function::New(*parameter.name,
                         RawFunction::kSignatureFunction,
                         /* is_static = */ false,
                         /* is_const = */ false,
                         /* is_abstract = */ false,
                         /* is_external = */ false,
                         /* is_native = */ false,
                         current_class(),
                         parameter.name_pos));
       signature_function.set_result_type(result_type);
+      signature_function.set_is_debuggable(false);
       AddFormalParamsToFunction(&func_params, signature_function);
       const String& signature = String::Handle(I,
                                                signature_function.Signature());
       // Lookup the signature class, i.e. the class whose name is the signature.
       // We only lookup in the current library, but not in its imports, and only
       // create a new canonical signature class if it does not exist yet.
       Class& signature_class = Class::ZoneHandle(I,
           library_.LookupLocalClass(signature));
       if (signature_class.IsNull()) {
         signature_class = Class::NewSignatureClass(signature,
@@ skipping 1462 matching lines @@
     }
   }
 
   RawFunction::AsyncModifier func_modifier = ParseFunctionModifier();
   func.set_modifier(func_modifier);
 
   OpenBlock();  // Open a nested scope for the outermost function block.
 
   Function& async_closure = Function::ZoneHandle(I);
   if (func.IsAsyncFunction() && !func.is_async_closure()) {
+    // The code of an async function is synthesized. Disable debugging.
+    func.set_is_debuggable(false);
     async_closure = OpenAsyncFunction(func.token_pos());
   } else if (func.is_async_closure()) {
+    // The closure containing the body of an async function is debuggable.
+    ASSERT(func.is_debuggable());
     OpenAsyncClosure();
   }
 
   BoolScope allow_await(&this->await_is_keyword_,
                         func.IsAsyncFunction() || func.is_async_closure());
   intptr_t end_token_pos = 0;
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     if (String::Handle(I, func.name()).Equals(Symbols::EqualOperator())) {
       const Class& owner = Class::Handle(I, func.Owner());
@@ skipping 623 matching lines @@
         getter = Function::New(getter_name,
                                RawFunction::kImplicitStaticFinalGetter,
                                field->has_static,
                                field->has_const,
                                /* is_abstract = */ false,
                                /* is_external = */ false,
                                /* is_native = */ false,
                                current_class(),
                                field->name_pos);
         getter.set_result_type(*field->type);
+        getter.set_is_debuggable(false);
         members->AddFunction(getter);
       }
     }
 
     // For instance fields, we create implicit getter and setter methods.
     if (!field->has_static) {
       String& getter_name = String::Handle(I,
                                            Field::GetterSymbol(*field->name));
       getter = Function::New(getter_name, RawFunction::kImplicitGetter,
                              field->has_static,
                              field->has_final,
                              /* is_abstract = */ false,
                              /* is_external = */ false,
                              /* is_native = */ false,
                              current_class(),
                              field->name_pos);
       ParamList params;
       ASSERT(current_class().raw() == getter.Owner());
       params.AddReceiver(ReceiverType(current_class()), field->name_pos);
       getter.set_result_type(*field->type);
+      getter.set_is_debuggable(false);
       AddFormalParamsToFunction(&params, getter);
       members->AddFunction(getter);
       if (!field->has_final) {
         // Build a setter accessor for non-const fields.
         String& setter_name = String::Handle(I,
                                              Field::SetterSymbol(*field->name));
         setter = Function::New(setter_name, RawFunction::kImplicitSetter,
                                field->has_static,
                                field->has_final,
                                /* is_abstract = */ false,
                                /* is_external = */ false,
                                /* is_native = */ false,
                                current_class(),
                                field->name_pos);
         ParamList params;
         ASSERT(current_class().raw() == setter.Owner());
         params.AddReceiver(ReceiverType(current_class()), field->name_pos);
         params.AddFinalParameter(TokenPos(),
                                  &Symbols::Value(),
                                  field->type);
         setter.set_result_type(Type::Handle(I, Type::VoidType()));
+        setter.set_is_debuggable(false);
         AddFormalParamsToFunction(&params, setter);
         members->AddFunction(setter);
       }
     }
 
     if (CurrentToken() != Token::kCOMMA) {
       break;
     }
     ConsumeToken();
     field->name_pos = this->TokenPos();
@@ skipping 579 matching lines @@
   getter = Function::New(getter_name,
                          RawFunction::kImplicitGetter,
                          /* is_static = */ false,
                          /* is_const = */ true,
                          /* is_abstract = */ false,
                          /* is_external = */ false,
                          /* is_native = */ false,
                          cls,
                          cls.token_pos());
   getter.set_result_type(int_type);
+  getter.set_is_debuggable(false);
   ParamList params;
   params.AddReceiver(&dynamic_type, cls.token_pos());
   AddFormalParamsToFunction(&params, getter);
   enum_members.AddFunction(getter);
 
   GrowableObjectArray& enum_names = GrowableObjectArray::Handle(I,
       GrowableObjectArray::New(8, Heap::kOld));
   const String& name_prefix =
       String::Handle(String::Concat(enum_name, Symbols::Dot()));
 
@@ skipping 126 matching lines @@
       Function::New(ctor_name,
                     RawFunction::kConstructor,
                     /* is_static = */ false,
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     /* is_external = */ false,
                     /* is_native = */ false,
                     cls,
                     cls.token_pos()));
   ctor.set_end_token_pos(ctor.token_pos());
+  ctor.set_is_debuggable(false);
   if (library_.is_dart_scheme() && library_.IsPrivate(ctor_name)) {
     ctor.set_is_visible(false);
   }
 
   ParamList params;
   // Add implicit 'this' parameter.
   const AbstractType* receiver_type = ReceiverType(cls);
   params.AddReceiver(receiver_type, cls.token_pos());
   // Add implicit parameter for construction phase.
   params.AddFinalParameter(cls.token_pos(),
@@ skipping 216 matching lines @@
       Function::New(*alias_name,
                     RawFunction::kSignatureFunction,
                     /* is_static = */ false,
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     /* is_external = */ false,
                     /* is_native = */ false,
                     function_type_alias,
                     alias_name_pos));
   signature_function.set_result_type(result_type);
+  signature_function.set_is_debuggable(false);
   AddFormalParamsToFunction(&func_params, signature_function);
 
   // Patch the signature function in the signature class.
   function_type_alias.PatchSignatureFunction(signature_function);
 
   const String& signature = String::Handle(I,
                                            signature_function.Signature());
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing function type alias '%s'\n",
               signature.ToCString());
@@ skipping 321 matching lines @@
         getter = Function::New(getter_name,
                                RawFunction::kImplicitStaticFinalGetter,
                                is_static,
                                is_const,
                                /* is_abstract = */ false,
                                /* is_external = */ false,
                                /* is_native = */ false,
                                current_class(),
                                name_pos);
         getter.set_result_type(type);
+        getter.set_is_debuggable(false);
         top_level->functions.Add(getter);
       }
     } else if (is_final) {
       ReportError(name_pos, "missing initializer for final or const variable");
     }
 
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
     } else if (CurrentToken() == Token::kSEMICOLON) {
       ConsumeToken();
@@ skipping 102 matching lines @@
                     is_static,
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     is_external,
                     is_native,
                     current_class(),
                     decl_begin_pos));
   func.set_result_type(result_type);
   func.set_end_token_pos(function_end_pos);
   func.set_modifier(func_modifier);
-  if (is_native && library_.is_dart_scheme() && library_.IsPrivate(func_name)) {
-    func.set_is_visible(false);
+  if (is_native) {
+    func.set_is_debuggable(false);
+    if (library_.is_dart_scheme() && library_.IsPrivate(func_name)) {
+      func.set_is_visible(false);
+    }
   }
   AddFormalParamsToFunction(&params, func);
   top_level->functions.Add(func);
   if (!is_patch) {
     library_.AddObject(func, func_name);
   } else {
     library_.ReplaceObject(func, func_name);
   }
   if (metadata_pos >= 0) {
     library_.AddFunctionMetadata(func, metadata_pos);
@@ skipping 118 matching lines @@
                     is_static,
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     is_external,
                     is_native,
                     current_class(),
                     decl_begin_pos));
   func.set_result_type(result_type);
   func.set_end_token_pos(accessor_end_pos);
   func.set_modifier(func_modifier);
-  if (is_native && library_.is_dart_scheme() &&
-      library_.IsPrivate(accessor_name)) {
-    func.set_is_visible(false);
+  if (is_native) {
+    func.set_is_debuggable(false);
+    if (library_.is_dart_scheme() && library_.IsPrivate(accessor_name)) {
+      func.set_is_visible(false);
+    }
   }
   AddFormalParamsToFunction(&params, func);
   top_level->functions.Add(func);
   if (!is_patch) {
     library_.AddObject(func, accessor_name);
   } else {
     library_.ReplaceObject(func, accessor_name);
   }
   if (metadata_pos >= 0) {
     library_.AddFunctionMetadata(func, metadata_pos);
@@ skipping 6786 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart