Begin refactoring of visitSendSet for unqualified updates.

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 221 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;
+
   AccessSemantics.expression()
       : kind = AccessKind.EXPRESSION;
 
   AccessSemantics.thisAccess()
       : kind = AccessKind.THIS;
 
   AccessSemantics.thisProperty()
       : kind = AccessKind.THIS_PROPERTY;
 
   AccessSemantics._(this.kind);
@@ skipping 16 matching lines @@
 
 
 class DynamicAccess extends AccessSemantics {
   final target;
 
   DynamicAccess.dynamicProperty(this.target)
       : super._(AccessKind.DYNAMIC_PROPERTY);
 
   DynamicAccess.ifNotNullProperty(this.target)
       : 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;
 
   ClassElement get classElement => element.enclosingClass;
 
   StaticAccess._(AccessKind kind, this.element)
       : super._(kind);
 
@@ skipping 61 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);
 }