Revert "Split TypedSelector into Selector and TypeMask."

pkg/compiler/lib/src/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;
 
 /**
  * Core implementation of resolution.
  *
  * Do not subclass or instantiate this class outside this library
@@ skipping 556 matching lines @@
       target = currentClass.lookupSuperByName(selector.memberName);
       // [target] may be null which means invoking noSuchMethod on
       // super.
       if (target == null) {
         target = reportAndCreateErroneousElement(
             node, name, MessageKind.NO_SUCH_SUPER_MEMBER,
             {'className': currentClass.name, 'memberName': name});
         // We still need to register the invocation, because we might
         // call [:super.noSuchMethod:] which calls
         // [JSInvocationMirror._invokeOn].
-        registry.registerDynamicInvocation(
-            new UniverseSelector(selector, null));
+        registry.registerDynamicInvocation(selector);
         registry.registerSuperNoSuchMethod();
       }
     } else if (Elements.isUnresolved(resolvedReceiver.element)) {
       return const NoneResult();
     } else if (resolvedReceiver.element.isClass) {
       ClassElement receiverClass = resolvedReceiver.element;
       receiverClass.ensureResolved(compiler);
       if (node.isOperator) {
         // When the resolved receiver is a class, we can have two cases:
         //  1) a static send: C.foo, or
@@ skipping 354 matching lines @@
           {'className': currentClass.name, 'memberName': name});
       if (alternateName != null) {
         target = currentClass.lookupSuperByName(alternateName);
       }
       if (target == null) {
         // If a setter wasn't resolved, use the [ErroneousElement].
         target = error;
       }
       // We still need to register the invocation, because we might
       // call [:super.noSuchMethod:] which calls [JSInvocationMirror._invokeOn].
-      registry.registerDynamicInvocation(new UniverseSelector(selector, null));
+      registry.registerDynamicInvocation(selector);
       registry.registerSuperNoSuchMethod();
     }
     return computeSuperAccessSemantics(node, target);
   }
 
   /// Resolve [node] as a subexpression that is _not_ the prefix of a member
   /// access. For instance `a` in `a + b`, as opposed to `a` in `a.b`.
   ResolutionResult visitExpression(Node node) {
     bool oldSendIsMemberAccess = sendIsMemberAccess;
     sendIsMemberAccess = false;
@@ skipping 107 matching lines @@
         if (semantics.kind == AccessKind.SUPER_METHOD) {
           registry.registerStaticUse(semantics.element.declaration);
         }
         // TODO(johnniwinther): Remove this when all information goes through
         // the [SendStructure].
         registry.useElement(node, semantics.element);
       }
     } else {
       ResolutionResult expressionResult = visitExpression(expression);
       semantics = new DynamicAccess.dynamicProperty(expression);
-      registry.registerDynamicInvocation(new UniverseSelector(selector, null));
+      registry.registerDynamicInvocation(selector);
 
       if (expressionResult.isConstant) {
         bool isValidConstant;
         ConstantExpression expressionConstant = expressionResult.constant;
         DartType knownExpressionType =
             expressionConstant.getKnownType(coreTypes);
         switch (operator.kind) {
           case UnaryOperatorKind.COMPLEMENT:
             isValidConstant =
                 knownExpressionType == coreTypes.intType;
@@ skipping 154 matching lines @@
           registry.registerStaticUse(semantics.element.declaration);
         }
         // TODO(johnniwinther): Remove this when all information goes through
         // the [SendStructure].
         registry.useElement(node, semantics.element);
       }
       visitExpression(right);
     } else {
       ResolutionResult leftResult = visitExpression(left);
       ResolutionResult rightResult = visitExpression(right);
-      registry.registerDynamicInvocation(new UniverseSelector(selector, null));
+      registry.registerDynamicInvocation(selector);
       semantics = new DynamicAccess.dynamicProperty(left);
 
       if (leftResult.isConstant && rightResult.isConstant) {
         bool isValidConstant;
         ConstantExpression leftConstant = leftResult.constant;
         ConstantExpression rightConstant = leftResult.constant;
         DartType knownLeftType = leftConstant.getKnownType(coreTypes);
         DartType knownRightType = rightConstant.getKnownType(coreTypes);
         switch (operator.kind) {
           case BinaryOperatorKind.EQ:
@@ skipping 111 matching lines @@
   ResolutionResult handleExpressionInvoke(Send node) {
     assert(invariant(node, node.isCall,
         message: "Unexpected expression: $node"));
     Node expression = node.selector;
     visitExpression(expression);
     CallStructure callStructure = resolveArguments(node.argumentsNode);
     Selector selector = callStructure.callSelector;
     // TODO(johnniwinther): Remove this when all information goes through the
     // [SendStructure].
     registry.setSelector(node, selector);
-    registry.registerDynamicInvocation(new UniverseSelector(selector, null));
+    registry.registerDynamicInvocation(selector);
     registry.registerSendStructure(node,
         new InvokeStructure(new AccessSemantics.expression(), selector));
     return const NoneResult();
   }
 
   /// Handle a, possibly invalid, assertion, like `assert(cond)` or `assert()`.
   ResolutionResult handleAssert(Send node) {
     assert(invariant(node, node.isCall,
         message: "Unexpected assert: $node"));
     // If this send is of the form "assert(expr);", then
@@ skipping 29 matching lines @@
   /// Handle access on `this`, like `this()` and `this` when it is parsed as a
   /// [Send] node.
   ResolutionResult handleThisAccess(Send node) {
     AccessSemantics accessSemantics = new AccessSemantics.thisAccess();
     if (node.isCall) {
       CallStructure callStructure = resolveArguments(node.argumentsNode);
       Selector selector = callStructure.callSelector;
       // TODO(johnniwinther): Handle invalid this access as an
       // [AccessSemantics].
       if (checkThisAccess(node)) {
-        registry.registerDynamicInvocation(
-            new UniverseSelector(selector, null));
+        registry.registerDynamicInvocation(selector);
         registry.registerSendStructure(node,
             new InvokeStructure(accessSemantics, selector));
       }
       // TODO(johnniwinther): Remove this when all information goes through
       // the [SendStructure].
       registry.setSelector(node, selector);
     } else {
       // TODO(johnniwinther): Handle get of `this` when it is a [Send] node.
       internalError(node, "Unexpected node '$node'.");
     }
@@ skipping 15 matching lines @@
       AccessSemantics semantics = computeSuperAccessSemanticsForSelector(
           node, selector, alternateName: name.setter);
       if (node.isCall) {
         bool isIncompatibleInvoke = false;
         switch (semantics.kind) {
           case AccessKind.SUPER_METHOD:
             MethodElementX superMethod = semantics.element;
             superMethod.computeSignature(compiler);
             if (!callStructure.signatureApplies(superMethod)) {
               registry.registerThrowNoSuchMethod();
-              registry.registerDynamicInvocation(
-                  new UniverseSelector(selector, null));
+              registry.registerDynamicInvocation(selector);
               registry.registerSuperNoSuchMethod();
               isIncompatibleInvoke = true;
             } else {
               registry.registerStaticInvocation(semantics.element);
             }
             break;
           case AccessKind.SUPER_FIELD:
           case AccessKind.SUPER_FINAL_FIELD:
           case AccessKind.SUPER_GETTER:
             registry.registerStaticUse(semantics.element);
             selector = callStructure.callSelector;
-            registry.registerDynamicInvocation(
-                new UniverseSelector(selector, null));
+            registry.registerDynamicInvocation(selector);
             break;
           case AccessKind.SUPER_SETTER:
           case AccessKind.UNRESOLVED_SUPER:
             // NoSuchMethod registered in [computeSuperSemantics].
             break;
           default:
             internalError(node, "Unexpected super property access $semantics.");
             break;
         }
         registry.registerSendStructure(node,
@@ skipping 205 matching lines @@
   }
 
   /// Handle dynamic access of [semantics].
   ResolutionResult handleDynamicAccessSemantics(
       Send node, Name name, AccessSemantics semantics) {
     SendStructure sendStructure;
     Selector selector;
     if (node.isCall) {
       CallStructure callStructure = resolveArguments(node.argumentsNode);
       selector = new Selector(SelectorKind.CALL, name, callStructure);
-      registry.registerDynamicInvocation(
-          new UniverseSelector(selector, null));
+      registry.registerDynamicInvocation(selector);
       sendStructure = new InvokeStructure(semantics, selector);
     } else {
       assert(invariant(node, node.isPropertyAccess));
       selector = new Selector(
           SelectorKind.GETTER, name, CallStructure.NO_ARGS);
-      registry.registerDynamicGetter(
-          new UniverseSelector(selector, null));
+      registry.registerDynamicGetter(selector);
       sendStructure = new GetStructure(semantics, selector);
     }
     registry.registerSendStructure(node, sendStructure);
     // TODO(johnniwinther): Remove this when all information goes through
     // the [SendStructure].
     registry.setSelector(node, selector);
     return const NoneResult();
   }
 
   /// Handle dynamic property access, like `a.b` or `a.b()` where `a` is not a
@@ skipping 63 matching lines @@
   }
 
   /// Handle erroneous access of [element] of the given [accessSemantics].
   ResolutionResult handleErroneousAccess(
       Send node, Name name, Element element, AccessSemantics accessSemantics) {
     SendStructure sendStructure;
     Selector selector;
     if (node.isCall) {
       CallStructure callStructure = resolveArguments(node.argumentsNode);
       selector = new Selector(SelectorKind.CALL, name, callStructure);
-      registry.registerDynamicInvocation(
-          new UniverseSelector(selector, null));
+      registry.registerDynamicInvocation(selector);
       sendStructure = new InvokeStructure(accessSemantics, selector);
     } else {
       assert(invariant(node, node.isPropertyAccess));
       selector = new Selector(
           SelectorKind.GETTER, name, CallStructure.NO_ARGS);
-      registry.registerDynamicGetter(
-          new UniverseSelector(selector, null));
+      registry.registerDynamicGetter(selector);
       sendStructure = new GetStructure(accessSemantics, selector);
     }
     // TODO(johnniwinther): Remove this when all information goes through
     // the [SendStructure].
     registry.setSelector(node, selector);
     registry.useElement(node, element);
     registry.registerSendStructure(node, sendStructure);
     return const NoneResult();
   }
 
@@ skipping 47 matching lines @@
       selector = new Selector(SelectorKind.GETTER, name, callStructure);
     }
     if (node.isCall) {
       bool isIncompatibleInvoke = false;
       switch (semantics.kind) {
         case AccessKind.LOCAL_FUNCTION:
           LocalFunctionElementX function = semantics.element;
           function.computeSignature(compiler);
           if (!callStructure.signatureApplies(function)) {
             registry.registerThrowNoSuchMethod();
-            registry.registerDynamicInvocation(
-                new UniverseSelector(selector, null));
+            registry.registerDynamicInvocation(selector);
             isIncompatibleInvoke = true;
           }
           break;
         case AccessKind.PARAMETER:
         case AccessKind.FINAL_PARAMETER:
         case AccessKind.LOCAL_VARIABLE:
         case AccessKind.FINAL_LOCAL_VARIABLE:
           selector = callStructure.callSelector;
-          registry.registerDynamicInvocation(
-              new UniverseSelector(selector, null));
+          registry.registerDynamicInvocation(selector);
           break;
         default:
           internalError(node,
               "Unexpected local access $semantics.");
           break;
       }
       registry.registerSendStructure(node,
           isIncompatibleInvoke
               ? new IncompatibleInvokeStructure(semantics, selector)
               : new InvokeStructure(semantics, selector));
@@ skipping 44 matching lines @@
         computeStaticOrTopLevelAccessSemantics(node, member);
     if (node.isCall) {
       bool isIncompatibleInvoke = false;
       switch (semantics.kind) {
         case AccessKind.STATIC_METHOD:
         case AccessKind.TOPLEVEL_METHOD:
           MethodElementX method = semantics.element;
           method.computeSignature(compiler);
           if (!callStructure.signatureApplies(method)) {
             registry.registerThrowNoSuchMethod();
-            registry.registerDynamicInvocation(
-                new UniverseSelector(selector, null));
+            registry.registerDynamicInvocation(selector);
             isIncompatibleInvoke = true;
           } else {
             registry.registerStaticUse(semantics.element);
             handleForeignCall(node, semantics.element, selector);
           }
           break;
         case AccessKind.STATIC_FIELD:
         case AccessKind.FINAL_STATIC_FIELD:
         case AccessKind.STATIC_GETTER:
         case AccessKind.TOPLEVEL_FIELD:
         case AccessKind.FINAL_TOPLEVEL_FIELD:
         case AccessKind.TOPLEVEL_GETTER:
           registry.registerStaticUse(semantics.element);
           selector = callStructure.callSelector;
-          registry.registerDynamicInvocation(
-              new UniverseSelector(selector, null));
+          registry.registerDynamicInvocation(selector);
           break;
         case AccessKind.STATIC_SETTER:
         case AccessKind.TOPLEVEL_SETTER:
         case AccessKind.UNRESOLVED:
           registry.registerThrowNoSuchMethod();
           member = reportAndCreateErroneousElement(
               node.selector, name.text,
               MessageKind.CANNOT_RESOLVE_GETTER, const {});
           break;
         default:
@@ skipping 202 matching lines @@
 
     if (node.isCall) {
       if (Elements.isUnresolved(target) ||
           target.isGetter ||
           target.isField ||
           Elements.isClosureSend(node, target)) {
         // If we don't know what we're calling or if we are calling a getter,
         // we need to register that fact that we may be calling a closure
         // with the same arguments.
         Selector call = new Selector.callClosureFrom(selector);
-        registry.registerDynamicInvocation(
-            new UniverseSelector(selector, null));
+        registry.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 (target is FunctionElement) {
           FunctionElement function = target;
           function.computeType(compiler);
         }
         if (!selector.applies(target, compiler.world)) {
@@ skipping 154 matching lines @@
               {'className': currentClass.name, 'memberName': selector.name});
           registry.registerSuperNoSuchMethod();
         }
       }
       registry.useElement(node.selector, getter);
 
       // Make sure we include the + and - operators if we are using
       // the ++ and -- ones.  Also, if op= form is used, include op itself.
       void registerBinaryOperator(String name) {
         Selector binop = new Selector.binaryOperator(name);
-        registry.registerDynamicInvocation(
-            new UniverseSelector(binop, null));
+        registry.registerDynamicInvocation(binop);
         registry.setOperatorSelectorInComplexSendSet(node, binop);
       }
       if (identical(source, '++')) {
         registerBinaryOperator('+');
         registry.registerInstantiatedClass(compiler.intClass);
       } else if (identical(source, '--')) {
         registerBinaryOperator('-');
         registry.registerInstantiatedClass(compiler.intClass);
       } else if (source.endsWith('=')) {
         registerBinaryOperator(Elements.mapToUserOperator(operatorName));
       }
     }
 
     registerSend(selector, setter);
     return new ResolutionResult.forElement(registry.useElement(node, setter));
   }
 
   void registerSend(Selector selector, Element target) {
     if (target == null || target.isInstanceMember) {
       if (selector.isGetter) {
-        registry.registerDynamicGetter(
-            new UniverseSelector(selector, null));
+        registry.registerDynamicGetter(selector);
       } else if (selector.isSetter) {
-        registry.registerDynamicSetter(
-            new UniverseSelector(selector, null));
+        registry.registerDynamicSetter(selector);
       } else {
-        registry.registerDynamicInvocation(
-            new UniverseSelector(selector, null));
+        registry.registerDynamicInvocation(selector);
       }
     } else if (Elements.isStaticOrTopLevel(target)) {
       // Avoid registration of type variables since they are not analyzable but
       // instead resolved through their enclosing type declaration.
       if (!target.isTypeVariable) {
         // [target] might be the implementation element and only declaration
         // elements may be registered.
         registry.registerStaticUse(target.declaration);
       }
     }
@@ skipping 606 matching lines @@
       }
       label.setContinueTarget();
       registry.useLabel(node, label);
     }
     registry.registerTargetOf(node, target);
     return const NoneResult();
   }
 
   registerImplicitInvocation(String name, int arity) {
     Selector selector = new Selector.call(name, null, arity);
-    registry.registerDynamicInvocation(new UniverseSelector(selector, null));
+    registry.registerDynamicInvocation(selector);
   }
 
   ResolutionResult visitAsyncForIn(AsyncForIn node) {
     registry.registerAsyncForIn(node);
     registry.setCurrentSelector(node, compiler.currentSelector);
-    registry.registerDynamicGetter(
-        new UniverseSelector(compiler.currentSelector, null));
+    registry.registerDynamicGetter(compiler.currentSelector);
     registry.setMoveNextSelector(node, compiler.moveNextSelector);
-    registry.registerDynamicInvocation(
-        new UniverseSelector(compiler.moveNextSelector, null));
+    registry.registerDynamicInvocation(compiler.moveNextSelector);
 
     visit(node.expression);
 
     Scope blockScope = new BlockScope(scope);
     visitForInDeclaredIdentifierIn(node.declaredIdentifier, node, blockScope);
     visitLoopBodyIn(node, node.body, blockScope);
     return const NoneResult();
   }
 
   ResolutionResult visitSyncForIn(SyncForIn node) {
     registry.registerSyncForIn(node);
     registry.setIteratorSelector(node, compiler.iteratorSelector);
-    registry.registerDynamicGetter(
-        new UniverseSelector(compiler.iteratorSelector, null));
+    registry.registerDynamicGetter(compiler.iteratorSelector);
     registry.setCurrentSelector(node, compiler.currentSelector);
-    registry.registerDynamicGetter(
-        new UniverseSelector(compiler.currentSelector, null));
+    registry.registerDynamicGetter(compiler.currentSelector);
     registry.setMoveNextSelector(node, compiler.moveNextSelector);
-    registry.registerDynamicInvocation(
-        new UniverseSelector(compiler.moveNextSelector, null));
+    registry.registerDynamicInvocation(compiler.moveNextSelector);
 
     visit(node.expression);
 
     Scope blockScope = new BlockScope(scope);
     visitForInDeclaredIdentifierIn(node.declaredIdentifier, node, blockScope);
     visitLoopBodyIn(node, node.body, blockScope);
     return const NoneResult();
   }
 
   void visitForInDeclaredIdentifierIn(
@@ skipping 411 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// 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);
 }