Fail more helpfully when invoking a null native function.

runtime/vm/native_entry.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/native_entry.h"
 
 #include "include/dart_api.h"
 
 #include "vm/bootstrap.h"
 #include "vm/code_patcher.h"
@@ skipping 21 matching lines @@
   __args__.SetAt(0, instance);
   Exceptions::ThrowByType(Exceptions::kArgument, __args__);
 }
 
 
 NativeFunction NativeEntry::ResolveNative(const Library& library,
                                           const String& function_name,
                                           int number_of_arguments,
                                           bool* auto_setup_scope) {
   // Now resolve the native function to the corresponding native entrypoint.
-  if (library.native_entry_resolver() == 0) {
+  if (library.native_entry_resolver() == NULL) {
     // Native methods are not allowed in the library to which this
     // class belongs in.
     return NULL;
   }
   Dart_NativeFunction native_function = NULL;
   {
     Thread* T = Thread::Current();
     TransitionVMToNative transition(T);
     Dart_EnterScope();  // Enter a new Dart API scope as we invoke API entries.
     Dart_NativeEntryResolver resolver = library.native_entry_resolver();
     native_function = resolver(Api::NewHandle(T, function_name.raw()),
                                number_of_arguments, auto_setup_scope);
     Dart_ExitScope();  // Exit the Dart API scope.
   }
   return reinterpret_cast<NativeFunction>(native_function);
 }
 
 
 const uint8_t* NativeEntry::ResolveSymbolInLibrary(const Library& library,
                                                    uword pc) {
   Dart_NativeEntrySymbol symbol_resolver =
       library.native_entry_symbol_resolver();
-  if (symbol_resolver == 0) {
+  if (symbol_resolver == NULL) {
     // Cannot reverse lookup native entries.
     return NULL;
   }
   return symbol_resolver(reinterpret_cast<Dart_NativeFunction>(pc));
 }
 
 
 const uint8_t* NativeEntry::ResolveSymbol(uword pc) {
   Thread* thread = Thread::Current();
   REUSABLE_GROWABLE_OBJECT_ARRAY_HANDLESCOPE(thread);
@@ skipping 149 matching lines @@
   const Class& cls = Class::Handle(zone, func.Owner());
   const Library& library = Library::Handle(zone, cls.library());
 
   *is_bootstrap_native =
       Bootstrap::IsBootstapResolver(library.native_entry_resolver());
 
   const String& native_name = String::Handle(zone, func.native_name());
   ASSERT(!native_name.IsNull());
 
   const int num_params = NativeArguments::ParameterCountForResolution(func);
-  return NativeEntry::ResolveNative(library, native_name, num_params,
-                                    is_auto_scope);
+  NativeFunction native_function = NativeEntry::ResolveNative(
+      library, native_name, num_params, is_auto_scope);
+  if (native_function == NULL) {
+    FATAL2("Failed to resolve native function '%s' in '%s'\n",
+           native_name.ToCString(), func.ToQualifiedCString());
+  }
+  return native_function;
 }
 
 
 uword NativeEntry::LinkNativeCallEntry() {
   uword entry = reinterpret_cast<uword>(NativeEntry::LinkNativeCall);
 #if defined(USING_SIMULATOR)
   entry = Simulator::RedirectExternalReference(
       entry, Simulator::kBootstrapNativeCall, NativeEntry::kNumArguments);
 #endif
   return entry;
@@ skipping 92 matching lines @@
     // Because this call is within a compilation unit, Clang doesn't respect
     // the ABI alignment here.
     NativeEntry::NoScopeNativeCallWrapperNoStackCheck(
         args, reinterpret_cast<Dart_NativeFunction>(target_function));
   }
 }
 #endif  // !defined(TARGET_ARCH_DBC)
 
 
 }  // namespace dart