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

runtime/vm/exceptions.cc

 // Copyright (c) 2011, 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/exceptions.h"
 
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/flags.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_stacktrace_at_throw, false,
             "Prints a stack trace everytime a throw occurs.");
 DEFINE_FLAG(bool, heap_profile_out_of_memory, false,
             "Writes a heap profile on unhandled out-of-memory exceptions.");
-
+DEFINE_FLAG(bool, verbose_stacktrace, false,
+            "Includes also core-lib's private methods");

[siva, 2013/01/19 01:12:13]

Should this be limited to just the core lib or all the other libraries too (e.g
dart:isolate, dart:io, dart:scalaralists etc.).

 
 const char* Exceptions::kCastErrorDstName = "type cast";
 
+static bool ShouldShowFunction(const Function& func) {
+  if (FLAG_verbose_stacktrace) return true;
+  const Class& owner = Class::Handle(func.Owner());
+  if (owner.library() != Library::CoreLibrary()) return true;
+  // Check if function is private, hide it if so.
+  const String& name = String::Handle(func.name());
+  for (intptr_t i = 0; i < name.Length(); i++) {
+    if (name.CharAt(i) == Scanner::kPrivateKeySeparator) {
+      return false;
+    }
+  }

[siva, 2013/01/19 01:12:13]

We should probably pull this code into a helper method in
class Function { ...} so that here we can just do
return func.IsPrivate() ? false : true;

+  return true;
+}
+
 
 // Iterate through the stack frames and try to find a frame with an
 // exception handler. Once found, set the pc, sp and fp so that execution
 // can continue in that frame.
 static bool FindExceptionHandler(uword* handler_pc,
                                  uword* handler_sp,
                                  uword* handler_fp,
                                  const GrowableObjectArray& func_list,
                                  const GrowableObjectArray& code_list,
                                  const GrowableObjectArray& pc_offset_list) {
@@ skipping 12 matching lines @@
         InlinedFunctionsInDartFrameIterator optimized_frames(frame);
         while (true) {
           uword pc = 0;
           func = optimized_frames.GetNextFunction(&pc);
           if (func.IsNull()) {
             break;
           }
           ASSERT(pc != 0);
           code = func.unoptimized_code();
           offset = Smi::New(pc - code.EntryPoint());
+          if (ShouldShowFunction(func)) {
+            func_list.Add(func);
+            code_list.Add(code);
+            pc_offset_list.Add(offset);
+          }
+        }
+      } else {
+        offset = Smi::New(frame->pc() - code.EntryPoint());
+        func = code.function();
+        if (ShouldShowFunction(func)) {
           func_list.Add(func);
           code_list.Add(code);
           pc_offset_list.Add(offset);
         }
-      } else {
-        offset = Smi::New(frame->pc() - code.EntryPoint());
-        func = code.function();
-        func_list.Add(func);
-        code_list.Add(code);
-        pc_offset_list.Add(offset);
       }
       if (frame->FindExceptionHandler(handler_pc)) {
         *handler_sp = frame->sp();
         *handler_fp = frame->fp();
         return true;
       }
     }
     frame = frames.NextFrame();
     ASSERT(frame != NULL);
   }
@@ skipping 385 matching lines @@
     case kIsolateUnhandledException:
       library = Library::IsolateLibrary();
       class_name = &Symbols::IsolateUnhandledException();
       break;
   }
 
   return DartLibraryCalls::ExceptionCreate(library, *class_name, arguments);
 }
 
 }  // namespace dart