dart2js cps: Keep interceptors in a separate field.

pkg/compiler/lib/src/cps_ir/cps_ir_integrity.dart

 library dart2js.cps_ir_integrity;
 
 import 'cps_ir_nodes.dart';
 import 'cps_ir_nodes_sexpr.dart';
 import '../tracer.dart' as tracer;
 
 /// Dump S-expressions on error if the tracer is enabled.
 ///
 /// Technically this has nothing to do with the tracer, but if you want one
 /// enabled, you typically want the other as well, so we use the same flag.
@@ skipping 116 matching lines @@
     enterScope(cont.parameters);
     // Put every continuation in scope at its own body. The isRecursive
     // flag is checked explicitly using [insideContinuations].
     enterScope([cont]);
     enterContinuation(cont);
     return cont.body;
   }
 
   @override
   visitFunctionDefinition(FunctionDefinition node) {
-    if (node.thisParameter != null) {
-      handleDeclaration(node.thisParameter);
-      enterScope([node.thisParameter]);
+    if (node.interceptorParameter != null) {
+      handleDeclaration(node.interceptorParameter);
+      enterScope([node.interceptorParameter]);
+    }
+    if (node.receiverParameter != null) {
+      handleDeclaration(node.receiverParameter);
+      enterScope([node.receiverParameter]);
     }
     node.parameters.forEach(handleDeclaration);
     enterScope(node.parameters);
     handleDeclaration(node.returnContinuation);
     enterScope([node.returnContinuation]);
     if (!node.returnContinuation.isReturnContinuation) {
       error('Return continuation with a body', node);
     }
     visit(node.body);
   }
@@ skipping 24 matching lines @@
       error('Recursive InvokeContinuation marked as non-recursive', node);
     }
     if (node.isRecursive && !target.isRecursive) {
       error('Recursive Continuation was not marked as recursive', node);
     }
     if (node.argumentRefs.length != target.parameters.length) {
       error('Arity mismatch in InvokeContinuation', node);
     }
   }
 
+  @override
+  processInvokeMethod(InvokeMethod node) {
+    if (node.callingConvention == CallingConvention.Intercepted) {
+      if (node.interceptorRef == null) {
+        error('No interceptor on intercepted call', node);
+      }
+    } else {
+      if (node.interceptorRef != null) {
+        error('Interceptor on call with ${node.callingConvention}', node);
+      }
+    }
+  }
+
   void checkReferenceChain(Definition def) {
     Reference previous = null;
     for (Reference ref = def.firstRef; ref != null; ref = ref.next) {
       if (ref.previous != ref) {
         // Reference was not seen during IR traversal, so it is orphaned.
         error('Orphaned reference in reference chain for $def', def);
       }
       // Repair the .previous link that was used for marking.
       ref.previous = previous;
       previous = ref;
@@ skipping 54 matching lines @@
   }
 
   @override
   processReference(Reference node) {
     if (node.parent != _parent) {
       error('Parent pointer on $node is ${node.parent} but should be $_parent',
             node);
     }
   }
 }