Rename is_visible to is_reflectable; use is_debuggable instead of is_reflectable

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 2151 matching lines @@
 
   RawArray* ic_data_array() const;
   void ClearICData() const;
 
   static const int kCtorPhaseInit = 1 << 0;
   static const int kCtorPhaseBody = 1 << 1;
   static const int kCtorPhaseAll = (kCtorPhaseInit | kCtorPhaseBody);
 
   void set_modifier(RawFunction::AsyncModifier value) const;
 
-  // An invisible function is hidden from stack traces, will not be enumerated
-  // by mirrors, and cannot be directly invoked by mirrors. All private
-  // functions in dart:* libraries are marked invisible by the parser.
+  // static: Considered during class-side or top-level resolution rather than
+  //         instance-side resolution.
+  // const: Valid target of a const constructor call.
+  // abstract: Skipped during instance-side resolution.
+  // reflectable: Enumerated by mirrors, invokable by mirrors. False for private
+  //              functions of dart: libraries.
+  // debuggable: Valid location of a break point. True for functions with source
+  //             code; false for synthetic functions such as dispatchers.
+  // optimizable: Candidate for for going through the optimizing compiler. False
+  //              for some functions known to be execute infrequently and
+  //              functions which have been de-optimized too many times.
+  // instrinsic: Has a hand-written assembly prologue.
+  // inlinable: Candidate for inlining. False for functions with features we
+  //            don't support during inlining (e.g., optional parameters),
+  //            functions which are too big, etc.
+  // native: Bridge to C/C++ code.
+  // redirecting: Redirecting generative or factory constructor.
+  // external: Expects to be defined in another patch file.
+

[Ivan Posva, 2015/01/23 19:37:07]

Thanks! This explanation was needed.

+  bool is_stacktrace_visible() const { return is_debuggable(); }
 
 #define FOR_EACH_FUNCTION_KIND_BIT(V)                                          \
   V(Static, is_static)                                                         \
   V(Const, is_const)                                                           \
   V(Abstract, is_abstract)                                                     \
-  V(Visible, is_visible)                                                       \
+  V(Reflectable, is_reflectable)                                               \
   V(Debuggable, is_debuggable)                                                 \
   V(Optimizable, is_optimizable)                                               \
   V(Inlinable, is_inlinable)                                                   \
   V(Intrinsic, is_intrinsic)                                                   \
   V(Native, is_native)                                                         \
   V(Redirecting, is_redirecting)                                               \
   V(External, is_external)                                                     \
   V(AllowsHoistingCheckClass, allows_hoisting_check_class)                     \
   V(AllowsBoundsCheckGeneralization, allows_bounds_check_generalization)       \
   V(AsyncClosure, is_async_closure)                                            \
@@ skipping 5513 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_