Avoid marking functions inlinable when FLAG_causal_async_stacks is false

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/flags.h"
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 #include "lib/invocation_mirror.h"
@@ skipping 3560 matching lines @@
     func.set_modifier(func_modifier);
   }
 
   OpenBlock();  // Open a nested scope for the outermost function block.
 
   Function& generated_body_closure = Function::ZoneHandle(Z);
   if (func.IsAsyncFunction()) {
     ASSERT(!func.is_generated_body());
     // The code of an async function is synthesized. Disable debugging.
     func.set_is_debuggable(false);
-    // In order to collect causal asynchronous stacks efficiently we rely on
-    // this function not being inlined.
-    func.set_is_inlinable(!FLAG_causal_async_stacks);
+    if (FLAG_causal_async_stacks) {
+      // In order to collect causal asynchronous stacks efficiently we rely on
+      // this function not being inlined.
+      func.set_is_inlinable(false);
+    }
     generated_body_closure = OpenAsyncFunction(func.token_pos());
   } else if (func.IsAsyncClosure()) {
     // The closure containing the body of an async function is debuggable.
     ASSERT(func.is_debuggable());
-    // In order to collect causal asynchronous stacks efficiently we rely on
-    // this function not being inlined.
-    func.set_is_inlinable(!FLAG_causal_async_stacks);
+    if (FLAG_causal_async_stacks) {
+      // In order to collect causal asynchronous stacks efficiently we rely on
+      // this function not being inlined.
+      func.set_is_inlinable(false);
+    }
     OpenAsyncClosure();
   } else if (func.IsSyncGenerator()) {
     // The code of a sync generator is synthesized. Disable debugging.
     func.set_is_debuggable(false);
     generated_body_closure = OpenSyncGeneratorFunction(func.token_pos());
   } else if (func.IsSyncGenClosure()) {
     // The closure containing the body of a sync generator is debuggable.
     ASSERT(func.is_debuggable());
     async_temp_scope_ = current_block_->scope;
   } else if (func.IsAsyncGenerator()) {
     func.set_is_debuggable(false);
-    // In order to collect causal asynchronous stacks efficiently we rely on
-    // this function not being inlined.
-    func.set_is_inlinable(!FLAG_causal_async_stacks);
+    if (FLAG_causal_async_stacks) {
+      // In order to collect causal asynchronous stacks efficiently we rely on
+      // this function not being inlined.
+      func.set_is_inlinable(false);
+    }
     generated_body_closure = OpenAsyncGeneratorFunction(func.token_pos());
   } else if (func.IsAsyncGenClosure()) {
     // The closure containing the body of an async* function is debuggable.
     ASSERT(func.is_debuggable());
-    // In order to collect causal asynchronous stacks efficiently we rely on
-    // this function not being inlined.
-    func.set_is_inlinable(!FLAG_causal_async_stacks);
+    if (FLAG_causal_async_stacks) {
+      // In order to collect causal asynchronous stacks efficiently we rely on
+      // this function not being inlined.
+      func.set_is_inlinable(false);
+    }
     OpenAsyncGeneratorClosure();
   }
 
   BoolScope allow_await(&this->await_is_keyword_,
                         func.IsAsyncOrGenerator() || func.is_generated_body());
   TokenPosition end_token_pos = TokenPosition::kNoSource;
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     if (String::Handle(Z, func.name()).Equals(Symbols::EqualOperator())) {
       const Class& owner = Class::Handle(Z, func.Owner());
@@ skipping 11445 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME