Hide private corelib's method from stack trace in exceptions.

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 99 matching lines @@
 RawClass* Object::language_error_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::unhandled_exception_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::unwind_error_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 #undef RAW_NULL
 
 
 const double MegamorphicCache::kLoadFactor = 0.75;
 
 
+// The following functions are marked as invisible, meaning they will be hidden
+// in the stack trace.
+// (Library, class name, method name)
+#define INVISIBLE_LIST(V)                                                      \
+  V(CoreLibrary, Object, _noSuchMethod)                                        \
+  V(CoreLibrary, List, _throwArgumentError)                                    \
+  V(CoreLibrary, AssertionErrorImplementation, _throwNew)                      \
+  V(CoreLibrary, TypeErrorImplementation, _throwNew)                           \
+  V(CoreLibrary, FallThroughErrorImplementation, _throwNew)                    \
+  V(CoreLibrary, AbstractClassInstantiationErrorImplementation, _throwNew)     \
+  V(CoreLibrary, NoSuchMethodError, _throwNew)                                 \
+  V(CoreLibrary, int, _throwFormatException)                                   \
+  V(CoreLibrary, int, _parse)                                                  \
+
+
+static void MarkFunctionAsInvisible(const Library& lib,
+                                    const char* class_name,
+                                    const char* function_name) {
+  ASSERT(!lib.IsNull());
+  const Class& cls = Class::Handle(
+      lib.LookupClass(String::Handle(String::New(class_name))));
+  ASSERT(!cls.IsNull());
+  const Function& function =
+      Function::Handle(
+          cls.LookupFunctionAllowPrivate(
+              String::Handle(String::New(function_name))));
+  ASSERT(!function.IsNull());
+  function.set_is_visible(false);
+}
+
+
+static void MarkInvisibleFunctions() {
+#define MARK_FUNCTION(lib, class_name, function_name)                          \
+  MarkFunctionAsInvisible(Library::Handle(Library::lib()),                     \
+      #class_name, #function_name);                                            \
+
+INVISIBLE_LIST(MARK_FUNCTION)
+#undef MARK_FUNCTION
+}
+
 // Takes a vm internal name and makes it suitable for external user.
 //
 // Examples:
 //
 // Internal getter and setter prefixes are changed:
 //
 //   get:foo -> foo
 //   set:foo -> foo=
 //
 // Private name mangling is removed, possibly twice:
@@ skipping 902 matching lines @@
     return error.raw();
   }
   Bootstrap::SetupNativeResolver();
 
   // Remove the Object superclass cycle by setting the super type to null (not
   // to the type of null).
   cls = object_store->object_class();
   cls.set_super_type(Type::Handle());
 
   ClassFinalizer::VerifyBootstrapClasses();
+  MarkInvisibleFunctions();
   return Error::null();
 }
 
 
 void Object::InitFromSnapshot(Isolate* isolate) {
   TIMERSCOPE(time_bootstrap);
   ObjectStore* object_store = isolate->object_store();
 
   Class& cls = Class::Handle();
 
@@ skipping 2579 matching lines @@
 
 
 bool Function::IsInlineable() const {
   // '==' call is handled specially.
   return InlinableBit::decode(raw_ptr()->kind_tag_) &&
          HasCode() &&
          name() != Symbols::EqualOperator().raw();
 }
 
 
+void Function::set_is_visible(bool value) const {
+  set_kind_tag(VisibleBit::update(value, raw_ptr()->kind_tag_));
+}
+
+
 intptr_t Function::NumParameters() const {
   return num_fixed_parameters() + NumOptionalParameters();
 }
 
 
 intptr_t Function::NumImplicitParameters() const {
   if (kind() == RawFunction::kConstructor) {
     if (is_static()) {
       ASSERT(IsFactory());
       return 1;  // Type arguments.
@@ skipping 389 matching lines @@
   ASSERT(!owner.IsNull());
   const Function& result = Function::Handle(Function::New());
   result.set_parameter_types(Object::empty_array());
   result.set_parameter_names(Object::empty_array());
   result.set_name(name);
   result.set_kind(kind);
   result.set_is_static(is_static);
   result.set_is_const(is_const);
   result.set_is_abstract(is_abstract);
   result.set_is_external(is_external);
+  result.set_is_visible(true);  // Will be computed later.
   result.set_intrinsic_kind(kUnknownIntrinsic);
   result.set_owner(owner);
   result.set_token_pos(token_pos);
   result.set_end_token_pos(token_pos);
   result.set_num_fixed_parameters(0);
   result.set_num_optional_parameters(0);
   result.set_usage_counter(0);
   result.set_deoptimization_counter(0);
   result.set_optimized_instruction_count(0);
   result.set_optimized_call_site_count(0);
@@ skipping 8683 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart