Write our JS blobs for handling native classes in Dart.

frog/leg/ssa/builder.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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 1835 matching lines @@
     push(new HInvokeClosure(selector, inputs));
   }
 
   void handleForeignJs(Send node) {
     Link<Node> link = node.arguments;
     // If the invoke is on foreign code, don't visit the first
     // argument, which is the type, and the second argument,
     // which is the foreign code.
     link = link.tail.tail;
     List<HInstruction> inputs = <HInstruction>[];
     addGenericSendArgumentsToList(link, inputs);

[ahe, 2012/03/26 13:43:45]

if (node.arguments.isEmpty() || node.arguments.tail.isEmpty()) {
  compiler.cancel('At least two arguments expected', node: node.arguments);
}

[ngeoffray, 2012/03/26 13:55:32]

Done.

-    LiteralString type = node.arguments.head;
-    LiteralString literal = node.arguments.tail.head;
-    compiler.ensure(literal is LiteralString);
-    compiler.ensure(type is LiteralString);
-    push(new HForeign(literal.dartString, type.dartString, inputs));
+    Node type = node.arguments.head;
+    Node literal = node.arguments.tail.head;
+    if (literal is !StringNode || literal.dynamic.isInterpolation) {
+      compiler.cancel('JS code must be a string literal', node: literal);
+    }
+    if (type is !LiteralString) {
+      compiler.cancel(
+          'The type of a JS expression must be a string literal', node: type);
+    }
+    push(new HForeign(
+        literal.dynamic.dartString, type.dynamic.dartString, inputs));
   }
 
   void handleForeignUnintercepted(Send node) {
     Link<Node> link = node.arguments;
     if (!link.tail.isEmpty()) {
       compiler.cancel(
           'More than one expression in UNINTERCEPTED()', node: node);
     }
     Expression expression = link.head;
     disableMethodInterception();
@@ skipping 62 matching lines @@
             'Isolate library and compiler mismatch', node: node);
       }
       HStatic target = new HStatic(element);
       add(target);
       List<HInstruction> inputs = <HInstruction>[target];
       addGenericSendArgumentsToList(link, inputs);
       push(new HInvokeStatic(Selector.INVOCATION_0, inputs));
     }
   }
 
+  void handleForeignJsToClosure(Send node) {
+    Node closure = node.arguments.head;
+    if (!node.arguments.tail.isEmpty()) {

[ahe, 2012/03/26 13:43:45]

See above.  You should probably test for node.arguments.isEmpty() in the begging
of this method:

if (node.arguments.isEmpty() || !node.arguments.tail.isEmpty()) {
  cancel

[ngeoffray, 2012/03/26 13:55:32]

Done.

+      compiler.cancel(
+          'Invalid number of arguments in JS_TO_CLOSURE',

[ahe, 2012/03/26 13:43:45]

'exactly one argument required'

[ngeoffray, 2012/03/26 13:55:32]

Done.

+          node: node);

[ahe, 2012/03/26 13:43:45]

node: node.arguments

[ngeoffray, 2012/03/26 13:55:32]

Done.

+    }
+    Element element = elements[closure];
+    if (!Elements.isStaticOrTopLevelFunction(element)) {
+      compiler.cancel(
+          'JS_TO_CLOSURE requires a static or top-level method',
+          node: closure);
+    }
+    FunctionElement function = element;
+    FunctionParameters parameters = element.computeParameters(compiler);
+    if (parameters.optionalParameterCount !== 0) {
+      compiler.cancel(
+          'JS_TO_CLOSURE does not handle closure with optional parameters',
+          node: closure);
+    }
+    visit(closure);
+    List<HInstruction> inputs = <HInstruction>[pop()];
+    String invocationName = compiler.namer.closureInvocationName(
+        new Selector(SelectorKind.INVOCATION,
+                     parameters.requiredParameterCount));
+    push(new HForeign(new SourceString('#.$invocationName'),
+                      const SourceString('var'),
+                      inputs));
+  }
+
   handleForeignSend(Send node) {
     Element element = elements[node];
     if (element === compiler.findHelper(const SourceString('JS'))) {

[ahe, 2012/03/26 13:43:45]

This is weird, I think. Wouldn't this be simpler:

if (element.name == const SourceString('JS')) {
...

[ngeoffray, 2012/03/26 13:55:32]

Yes, but I thought we agreed on comparing elements and not names. 

[ahe, 2012/03/26 14:01:23]

In general yes, however, this is going too far in the other direction :-)

You could add this assertion if that would make you feel better:

assert(element.getLibrary() === compiler.jsHelperLibrary);

[ngeoffray, 2012/03/26 14:13:44]

No that's ok (a foreign element can only be created by us), I'll just check
against the name.

       handleForeignJs(node);
     } else if (element === compiler.findHelper(
           const SourceString('UNINTERCEPTED'))) {
       handleForeignUnintercepted(node);
     } else if (element === compiler.findHelper(
           const SourceString('JS_HAS_EQUALS'))) {
       handleForeignJsHasEquals(node);
     } else if (element === compiler.findHelper(
           const SourceString('JS_CURRENT_ISOLATE'))) {
       handleForeignJsCurrentIsolate(node);
     } else if (element === compiler.findHelper(
           const SourceString('JS_CALL_IN_ISOLATE'))) {
       handleForeignJsCallInIsolate(node);
+    } else if (element === compiler.findHelper(
+          const SourceString('JS_TO_CLOSURE'))) {
+      handleForeignJsToClosure(node);
     } else if (element === currentLibrary.find(const SourceString('native'))) {
       native.handleSsaNative(this, node);
     } else {
       throw "Unknown foreign: ${node.selector}";
     }
   }
 
   visitSuperSend(Send node) {
     Selector selector = elements.getSelector(node);
     Element element = elements[node];
@@ skipping 958 matching lines @@
                                         false,
                                         <HInstruction>[target, input]));
     return builder.pop();
   }
 
   HInstruction result() {
     flushLiterals();
     return prefix;
   }
 }