Check for the type of the the spawned function.

runtime/lib/isolate_patch.dart

 // 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.
 
 import "dart:collection" show HashMap;
 import "dart:_internal";
 
 @patch class ReceivePort {
   @patch factory ReceivePort() = _ReceivePortImpl;
 
@@ skipping 175 matching lines @@
   }
 
   /*--- private implementation ---*/
   _get_id() native "SendPortImpl_get_id";
   _get_hashcode() native "SendPortImpl_get_hashcode";
 
   // Forward the implementation of sending messages to the VM.
   void _sendInternal(var message) native "SendPortImpl_sendInternal_";
 }
 
-typedef _MainFunction();
-typedef _MainFunctionArgs(args);
-typedef _MainFunctionArgsMessage(args, message);
+typedef _NullaryFunction();
+typedef _UnaryFunction(args);
+typedef _BinaryFunction(args, message);
 
 /**
  * Takes the real entry point as argument and invokes it with the
  * initial message.  Defers execution of the entry point until the
  * isolate is in the message loop.
  */
 void _startMainIsolate(Function entryPoint,
                        List<String> args) {
   _startIsolate(null,   // no parent port
                 entryPoint,
@@ skipping 37 matching lines @@
   assert(capabilities == null);
 
   // Delay all user code handling to the next run of the message loop. This
   // allows us to intercept certain conditions in the event dispatch, such as
   // starting in paused state.
   RawReceivePort port = new RawReceivePort();
   port.handler = (_) {
     port.close();
 
     if (isSpawnUri) {
-      if (entryPoint is _MainFunctionArgsMessage) {
+      if (entryPoint is _BinaryFunction) {
         entryPoint(args, message);
-      } else if (entryPoint is _MainFunctionArgs) {
+      } else if (entryPoint is _UnaryFunction) {
         entryPoint(args);
       } else {
         entryPoint();
       }
     } else {
       entryPoint(message);
     }
   };
   // Make sure the message handler is triggered.
   port.sendPort.send(null);
@@ skipping 34 matching lines @@
       (VMLibraryHooks.packageConfigUriFuture != null) &&
       (VMLibraryHooks.resolvePackageUriFuture != null);
 
   @patch static Future<Isolate> spawn(
       void entryPoint(message), var message,
       {bool paused: false, bool errorsAreFatal,
        SendPort onExit, SendPort onError}) async {
     // `paused` isn't handled yet.
     RawReceivePort readyPort;
     try {
+      // Check for the type of `entryPoint` on the spawning isolate to make
+      // error-handling easier.
+      if (entryPoint is! _UnaryFunction) {
+        throw new ArgumentError(entryPoint);
+      }
       // The VM will invoke [_startIsolate] with entryPoint as argument.
       readyPort = new RawReceivePort();
 
       // We do not inherit the package root or package config settings
       // from the parent isolate, instead we use the values that were
       // set on the command line.
       var packageRoot = VMLibraryHooks.packageRootString;
       var packageConfig = VMLibraryHooks.packageConfigString;
       var script = VMLibraryHooks.platformScript;
       if (script == null) {
@@ skipping 250 matching lines @@
     try {
       return Uri.parse(_getCurrentRootUriStr());
     } catch (e, s) {
       return null;
     }
   }
 
   static String _getCurrentRootUriStr()
       native "Isolate_getCurrentRootUriStr";
 }