Add some magic to _getJSFunctionName so it will work in Internet Explorer.

frog/lib/isolate.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.
 
 /**
  * A native object that is shared across isolates. This object is visible to all
  * isolates running on the same worker (either UI or background web worker).
  *
  * This is code that is intended to 'escape' the isolate boundaries in order to
  * implement the semantics of friendly isolates in JavaScript. Without this we
@@ skipping 739 matching lines @@
   static var _getJSConstructor(Isolate runnable) native """
     return runnable.constructor;
   """;
 
   /** Extract the constructor name of a runnable */
   // TODO(sigmund): find a browser-generic way to support this.
   static var _getJSConstructorName(Isolate runnable) native """
     return runnable.constructor.name;
   """;
 
-  /** Find a constructor given it's name. */
+  /** Find a constructor given its name. */

[Siggi Cherem (dart-lang), 2012/02/22 23:46:49]

thx :)

   static var _getJSConstructorFromName(String factoryName) native """
     return \$globalThis[factoryName];
   """;
 
   static var _getJSFunctionFromName(String functionName) native """
     return \$globalThis[functionName];
   """;
 
-  static String _getJSFunctionName(Function f) native "return f.name || null;";
+  /** Get a string name for the function, if possible.  The result for

[Siggi Cherem (dart-lang), 2012/02/22 23:46:49]

(nit) style of the comment block: if it's multiline, we break the first and last
line:
/**
 * ...
 * ...
 */

[eub, 2012/02/23 00:00:12]

Done.

+   *  anonymous functions is browser-dependent -- it may be "" or "anonymous"
+   *  but you should probably not count on this. */
+  static String _getJSFunctionName(Function f) native """

[kasperl, 2012/02/23 06:53:35]

Can't we simplify this whole thing by not using .name? We can always stick an
extra field on the functions where we need to be able to look them up in the
"global" namespace. That will also give us a trivial way to figure out if
something is a static or a top-level function (not just some random function
that happens to have a name that we can resolve in the global scope).

I can think of three issues with my proposal:

(1) Setting up the .name property is shorter.
(2) We want to be able to spawn from functions that aren't written by us
(pre-existing JavaScript functions?).
(3) It's nice to have a good .name property anyway to make it easier to debug at
the JavaScript level.

[Siggi Cherem (dart-lang), 2012/02/23 17:13:23]

Yes, we debated a bit about this, and were afraid of mainly #1. If we go down
the route of setting a field on each static or top-level function, we could do
this in 3 ways:
a- setting it on every function
b- asking the programmer to specify which functions to tag.
c- setting it on functions that may be passed to spawn.

(a) feels like too much, (b) feels like it is to awkward to work with, (c) would
be nice, but we need a good static approach to approximate which functions may
be passed to spawn.

This morning I was just thinking of one possible approach for (c). We could say
that we only tag functions that the program refers to as a symbol expression
(not a call). For example, in this program:

void a() {}
void b() {}
void c() {}
void d() { return c; }
main() {
  b();
  final x = a;
  spawnFunction(x == null ? x : d());
}
we would tag 'a' and 'c', but not 'b' or 'd'. We could also say that if
'dart:isolate' is never imported, then we don't tag any function. 

I believe this wouldn't be hard to implement in frog, but I'm not 100% sure.
Thoughts?

[kasperl, 2012/02/27 11:28:24]

Option (c) sounds good to me. That should be even better than always emitting
named functions for static functions.

+    // Are we in a browser that implements the non-standard but
+    // oh-so-convenient function .name property?

[Siggi Cherem (dart-lang), 2012/02/22 23:46:49]

some of these comments are useful, but note that comments within native blocks
will be preserved in the generated output from frog until we have a minimizer in
place. Maybe we can remove some of the self explanatory comments below?

[eub, 2012/02/23 00:00:12]

Removed a little chatter, and moved the implementation comment out of the native
string (without letting it mash into the doc comment).

+    if (typeof(f.name) === 'undefined') {
+      // No.  Parse the name out of toString()!
+      //
+      // When there is a match, our capture is element 1 of the results list.
+      // If there is no match, match() returns null; we || this to a list
+      // whose element 1 is null so everything lines up without error.
+      // (Double-backslash in this string gives a backslash in the native JS.)
+      return (f.toString().match(/function (.+)\\(/) || [, null])[1];
+    } else {
+      // Yes.  Use .name property.
+      return f.name || null;
+    }
+  """;
 
   /** Create a new JavasSript object instance given it's constructor. */
   static var _allocate(var ctor) native "return new ctor();";
 
   /** Starts a non-worker isolate. */
   static SendPort _startNonWorker(Isolate runnable, SendPort replyTo) {
     // Spawn a new isolate and create the receive port in it.
     final spawned = new IsolateContext();
 
     // Instead of just running the provided runnable, we create a
@@ skipping 108 matching lines @@
       throw new UnsupportedOperationException(
           "only top-level functions can be spawned.");
     }
     return new Isolate2Impl(IsolateNatives._spawn2(name, null, false));
   }
 
   factory Isolate2.fromUri(String uri) {
     return new Isolate2Impl(IsolateNatives._spawn2(null, uri, false));
   }
 }