Handle more unqualified SendSets

pkg/compiler/lib/src/resolution/access_semantics.dart

 // Copyright (c) 2015, 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.
 
 // TODO(johnniwinther): Temporarily copied from analyzer2dart. Merge when
 // we shared code with the analyzer and this semantic visitor is complete.
 
 /**
  * Code for classifying the semantics of identifiers appearing in a Dart file.
  */
@@ skipping 197 matching lines @@
   ConstantExpression get constant => null;
 
   /// The element for the getter in case of a compound access,
   /// [element] otherwise.
   Element get getter => element;
 
   /// The element for the setter in case of a compound access,
   /// [element] otherwise.
   Element get setter => element;
 
-  // TODO(johnniwinther): Make access semantics getter/setter specific.
-  /// `true` if the [element] of this access is accessed statically.
-  bool get isAccessedStatically => false;
-
   const AccessSemantics._(this.kind);
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.write('AccessSemantics[');
     sb.write('kind=$kind,');
     if (element != null) {
       sb.write('element=');
       if (element.enclosingClass != null) {
         sb.write('${element.enclosingClass.name}.');
@@ skipping 14 matching lines @@
       : super._(AccessKind.THIS);
 
   const DynamicAccess.thisProperty()
       : super._(AccessKind.THIS_PROPERTY);
 
   const DynamicAccess.dynamicProperty()
       : super._(AccessKind.DYNAMIC_PROPERTY);
 
   const DynamicAccess.ifNotNullProperty()
       : super._(AccessKind.CONDITIONAL_DYNAMIC_PROPERTY);
-
-  bool get isAccessedStatically => false;
 }
 
 class ConstantAccess extends AccessSemantics {
   final ConstantExpression constant;
 
   ConstantAccess(AccessKind kind, this.constant)
       : super._(kind);
 
   ConstantAccess.classTypeLiteral(this.constant)
       : super._(AccessKind.CLASS_TYPE_LITERAL);
 
   ConstantAccess.typedefTypeLiteral(this.constant)
       : super._(AccessKind.TYPEDEF_TYPE_LITERAL);
 
   ConstantAccess.dynamicTypeLiteral(this.constant)
       : super._(AccessKind.DYNAMIC_TYPE_LITERAL);
-
-  bool get isAccessedStatically => false;
 }
 
 class StaticAccess extends AccessSemantics {
   final Element element;
 
   StaticAccess._(AccessKind kind, this.element)
       : super._(kind);
 
   StaticAccess.superSetter(MethodElement this.element)
       : super._(AccessKind.SUPER_SETTER);
@@ skipping 59 matching lines @@
       : super._(AccessKind.TOPLEVEL_SETTER);
 
   StaticAccess.unresolved(this.element)
       : super._(AccessKind.UNRESOLVED);
 
   StaticAccess.unresolvedSuper(this.element)
       : super._(AccessKind.UNRESOLVED_SUPER);
 
   StaticAccess.invalid(this.element)
       : super._(AccessKind.INVALID);
-
-  bool get isAccessedStatically {
-    switch (kind) {
-      case AccessKind.UNRESOLVED:
-      case AccessKind.UNRESOLVED_SUPER:
-      case AccessKind.INVALID:
-      case AccessKind.TYPE_PARAMETER_TYPE_LITERAL:
-        return false;
-      default:
-        return true;
-    }
-  }
 }
 
 class CompoundAccessSemantics extends AccessSemantics {
   final CompoundAccessKind compoundAccessKind;
   final Element getter;
   final Element setter;
 
   CompoundAccessSemantics(this.compoundAccessKind,
                           this.getter,
                           this.setter)
       : super._(AccessKind.COMPOUND);
 
   Element get element => setter;
 
-  // TODO(johnniwinther): Discriminate between access of the getter and setter.
-  bool get isAccessedStatically => true;
-
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.write('CompoundAccessSemantics[');
     sb.write('kind=$compoundAccessKind');
     if (getter != null) {
       sb.write(',getter=');
       sb.write('${getter}');
     }
     if (setter != null) {
       sb.write(',setter=');
@@ skipping 148 matching lines @@
 
   RedirectingFactoryConstructorAccessSemantics(
       ConstructorAccessKind kind,
       Element element,
       DartType type,
       this.effectiveTargetSemantics)
       : super(kind, element, type);
 }