Refactor qualified send sets.

pkg/compiler/lib/src/elements/elements.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.
 
 library elements;
 
 import '../compiler.dart' show
     Compiler,
     isPrivateName;
 import '../constants/constructors.dart';
@@ skipping 503 matching lines @@
     if (element.isNative) return true;
     assert(element.isResolved);
     return isNativeOrExtendsNative(element.superclass);
   }
 
   static bool isInstanceSend(Send send, TreeElements elements) {
     Element element = elements[send];
     if (element == null) return !isClosureSend(send, element);
     return isInstanceMethod(element) ||
            isInstanceField(element) ||
-           send.isConditional;
+           (send.isConditional && !element.isStatic);

[Siggi Cherem (dart-lang), 2015/08/24 21:25:17]

I think it should be fine to delete this whole line, if !element.isStatic, one
of the other two conditions will be true already.

[Johnni Winther, 2015/08/25 07:25:58]

This makes C?.foo _not_ an instance-send.

[Siggi Cherem (dart-lang), 2015/08/25 15:48:06]

I'm probably missing something - isInstanceMethod and isInstanceField are always
false when element.isStatic. So it seems to me that this condition is equivalent
to:

  return isInstanceMethod(element) || isInstnaceField(element);

(when I added `send.isConditional` it only added it because C?.foo used to be an
instance-send, now that this is no longer true, I thought we wouldn't need the
special case for send.isConditional altogether)

[Johnni Winther, 2015/08/26 07:18:35]

Ahh. I didn't go into the cases of isInstanceMethod and isInstanceField. In any
case, methods like this should be removed and replaced by predicates on elements
if necessary. Not only is the reasoning often unclear, the implementation is
also based on a closed world of elements.

   }
 
   static bool isClosureSend(Send send, Element element) {
     if (send.isPropertyAccess) return false;
     if (send.receiver != null) return false;
     Node selector = send.selector;
     // this().
     if (selector.isThis()) return true;
     // (o)() or foo()().
     if (element == null && selector.asIdentifier() == null) return true;
@@ skipping 118 matching lines @@
     if (identical(op, '<<=')) return '<<';
     if (identical(op, '>>=')) return '>>';
     if (identical(op, '&=')) return '&';
     if (identical(op, '^=')) return '^';
     if (identical(op, '|=')) return '|';
     if (identical(op, '??=')) return '??';
 
     return null;
   }
 
-  static String mapToUserOperator(String op) {
-    String userOperator = mapToUserOperatorOrNull(op);
-    if (userOperator == null) throw 'Unhandled operator: $op';
-    else return userOperator;
-  }
-
   static bool isNumberOrStringSupertype(Element element, Compiler compiler) {
     LibraryElement coreLibrary = compiler.coreLibrary;
     return (element == coreLibrary.find('Comparable'));
   }
 
   static bool isStringOnlySupertype(Element element, Compiler compiler) {
     LibraryElement coreLibrary = compiler.coreLibrary;
     return element == coreLibrary.find('Pattern');
   }
 
@@ skipping 978 matching lines @@
   bool get isDeclaredByField;
 
   /// Returns `true` if this member is abstract.
   bool get isAbstract;
 
   /// If abstract, [implementation] points to the overridden concrete member,
   /// if any. Otherwise [implementation] points to the member itself.
   Member get implementation;
 }