Rename is_visible to is_reflectable; use is_debuggable instead of is_reflectable

runtime/vm/object.h

Index: runtime/vm/object.h
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index 7d9f4633a3a3ec3cba4f9d11ae007d9b620eec92..8fe6af1ab60d5a8c3fc51351c124030a78faf3bf 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -2169,15 +2169,32 @@ class Function : public Object {
 
   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)                                                   \