Implement JS_INTERCEPTOR_CONSTANT

sdk/lib/_internal/compiler/implementation/resolution/members.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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Setlet<Node> get superUses;
 
@@ skipping 1908 matching lines @@
   bool inCheckContext;
   bool inCatchBlock;
   Scope scope;
   ClassElement currentClass;
   ExpressionStatement currentExpressionStatement;
   bool sendIsMemberAccess = false;
   StatementScope statementScope;
   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.
   bool allowFinalWithoutInitializer = false;
 
   /// The nodes for which variable access and mutation must be registered in
   /// order to determine when the static type of variables types is promoted.
   Link<Node> promotionScope = const Link<Node>();
 
   bool isPotentiallyMutableTarget(Element target) {
@@ skipping 676 matching lines @@
         Selector call = new Selector.callClosureFrom(selector);
         world.registerDynamicInvocation(call);
       } else if (target.impliesType()) {
         // We call 'call()' on a Type instance returned from the reference to a
         // class or typedef literal. We do not need to register this call as a
         // dynamic invocation, because we statically know what the target is.
       } else if (!selector.applies(target, compiler)) {
         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);
+          }
+        }
       }
     }
 
     // TODO(ngeoffray): Warn if target is null and the send is
     // unqualified.
     useElement(node, target);
     registerSend(selector, target);
     if (node.isPropertyAccess && Elements.isStaticOrTopLevelFunction(target)) {
       world.registerGetOfStaticFunction(target.declaration);
     }
@@ skipping 396 matching lines @@
     }
     if (node.isConst()) {
       analyzeConstant(node);
     }
 
     return null;
   }
 
   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);
+         }
+       }
     });
   }
 
   bool validateSymbol(Node node, String name, {bool reportError: true}) {
     if (name.isEmpty) return true;
     if (name.startsWith('_')) {
       if (reportError) {
         compiler.reportError(node, MessageKind.PRIVATE_IDENTIFIER,
                              {'value': name});
       }
@@ skipping 1624 matching lines @@
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }