Implement JS_INTERCEPTOR_CONSTANT

sdk/lib/_internal/compiler/implementation/resolution/members.dart

Index: sdk/lib/_internal/compiler/implementation/resolution/members.dart
diff --git a/sdk/lib/_internal/compiler/implementation/resolution/members.dart b/sdk/lib/_internal/compiler/implementation/resolution/members.dart
index 015402a3b49b7bc5a7b69fcfec5208f8db817a64..cbc31ee2ed7ec69c460043573db688f07e400ac3 100644
--- a/sdk/lib/_internal/compiler/implementation/resolution/members.dart
+++ b/sdk/lib/_internal/compiler/implementation/resolution/members.dart
@@ -1926,6 +1926,12 @@ class ResolverVisitor extends MappingVisitor<Element> {
   int allowedCategory = ElementCategory.VARIABLE | ElementCategory.FUNCTION
       | ElementCategory.IMPLIES_TYPE;
 
+  /**
+   * Record of argument nodes to JS_INTERCEPTOR_CONSTANT for deferred
+   * processing.
+   */
+  Set<Node> argumentsToJsInterceptorConstant = null;

[ngeoffray, 2013/10/29 20:30:18]

This does not look very resolver related... why not doing it as a
post-processing action on the AST?

Also, I always feel nervous about adding state to the resolver.

[sra1, 2013/10/30 17:18:18]

Because it causes more classes to be instantiated, which adds their methods to
the resolver queue, so it has to be during resolution.
Me too.

The resolver is a set of actions that happen when the arguments are ready.
What makes it hard is that some of the actions are done by control flow
(visitors) and others by ad-hoc implementations of the RETE algorithm
(http://en.wikipedia.org/wiki/Rete_algorithm).

This action needs to be deferred since the arguments can't be forced into the
'ready' state by control flow.

What bothers me about this piece of state is not that there is state or too much
state, but that there is not enough state - implicit is that all dependencies of
the argument expression need to be resolved in order to evaluate the constant. 
There is no representation of the readiness of the resolution state.

It would be tedious and probably memory-hungry to convert all steps to actions
that happen when the inputs are ready, but that might be possible efficiently if
resolution was coded in a language that directly supported both demand-driven
and data-driven computation.

+
   /// When visiting the type declaration of the variable in a [ForIn] loop,
   /// the initializer of the variable is implicit and we should not emit an
   /// error when verifying that all final variables are initialized.
@@ -2622,10 +2628,17 @@ class ResolverVisitor extends MappingVisitor<Element> {
         warnArgumentMismatch(node, target);
       }
 
-      if (target != null &&
-          target.isForeign(compiler) &&
-          selector.name == 'JS') {
-        world.registerJsCall(node, this);
+      if (target != null && target.isForeign(compiler)) {
+        if (selector.name == 'JS') {
+          world.registerJsCall(node, this);
+        } else if (selector.name == 'JS_INTERCEPTOR_CONSTANT') {
+          if (!node.argumentsNode.isEmpty) {
+            Node argument = node.argumentsNode.nodes.head;
+            if (argumentsToJsInterceptorConstant == null)

[ngeoffray, 2013/10/29 20:30:18]

Please use braces.

[sra1, 2013/10/30 17:18:18]

I will sneak this into another CL.

+              argumentsToJsInterceptorConstant = new Set<Node>();
+            argumentsToJsInterceptorConstant.add(argument);
+          }
+        }
       }
     }
 
@@ -3042,8 +3055,28 @@ class ResolverVisitor extends MappingVisitor<Element> {
 
   void analyzeConstant(Node node, {bool isConst: true}) {
     addDeferredAction(enclosingElement, () {
-       compiler.constantHandler.compileNodeWithDefinitions(
+       Constant constant = compiler.constantHandler.compileNodeWithDefinitions(
            node, mapping, isConst: isConst);
+
+       // The type constant that is an argument to JS_INTERCEPTOR_CONSTANT names
+       // a class that will be instantiated outside the program by attaching a
+       // native class dispatch record referencing the interceptor.
+       if (argumentsToJsInterceptorConstant != null &&
+           argumentsToJsInterceptorConstant.contains(node)) {
+         if (constant.isType()) {
+           TypeConstant typeConstant = constant;
+           if (typeConstant.representedType is InterfaceType) {
+             world.registerInstantiatedType(typeConstant.representedType,
+                 mapping);
+           } else {
+             compiler.reportError(node,
+                 MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
+           }
+         } else {
+           compiler.reportError(node,
+               MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
+         }
+       }
     });
   }