Add tree shaker support for setters and field writes.

pkg/analyzer2dart/lib/src/tree_shaker.dart

 // Copyright (c) 2014, 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 analyzer2dart.treeShaker;
 
 import 'dart:collection';
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 119 matching lines @@
       for (PropertyAccessorElement accessor in classElement.accessors) {
         if (accessor.isGetter && selector.name == accessor.name) {
           if (accessor.isSynthetic) {
             // This accessor is implied by the corresponding field declaration.
             fields.add(accessor.variable);
           } else {
             accessors.add(accessor);
           }
         }
       }
+    } else if (selector.kind == SelectorKind.SETTER) {
+      for (PropertyAccessorElement accessor in classElement.accessors) {
+        // accessor.name uses the convention that setter names end in '='.
+        if (accessor.isSetter && '${selector.name}=' == accessor.name) {

[scheglov, 2014/10/21 14:58:21]

We could probably make it slightly faster by computing '${selector.name}='
outside of the loop.

[Paul Berry, 2014/10/21 15:14:04]

Done.

+          if (accessor.isSynthetic) {
+            // This accessor is implied by the corresponding field declaration.
+            // TODO(paulberry): should we distinguish reads and writes?
+            fields.add(accessor.variable);
+          } else {
+            accessors.add(accessor);
+          }
+        }
+      }
     }
   }
 }
 
 /**
  * This class is responsible for driving the tree shaking process, and
  * and performing the global inferences necessary to determine which methods
  * in the source program are reachable.  It makes use of
  * [LocalReachabilityComputer] to do local analysis of individual classes and
  * methods.
@@ skipping 137 matching lines @@
     // Invocation of a property.  TODO(paulberry): handle this.
     super.visitStaticPropertyInvocation(node, semantics);
   }
 
   void visitDynamicAccess(AstNode node, AccessSemantics semantics) {
     if (semantics.isRead) {
       analysis.invokes.add(
           new Selector.getter(semantics.identifier.name, null));
     }
     if (semantics.isWrite) {
-      // TODO(paulberry): implement.
-      return giveUp(node, '_handlePropertyAccess of ${semantics}.');
+      // Selector.setter constructor uses the convention that setter names
+      // don't end in '='.
+      analysis.invokes.add(
+          new Selector.setter(semantics.identifier.name, null));
     }
   }
 
   void visitLocalFunctionAccess(AstNode node, AccessSemantics semantics) {
     // Locals don't need to be tree shaken.
   }
 
   void visitLocalVariableAccess(AstNode node, AccessSemantics semantics) {
     // Locals don't need to be tree shaken.
   }
@@ skipping 43 matching lines @@
 
   @override
   void
       visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     // Note: we don't have to worry about node.staticElement being
     // null, because that would have been detected by the analyzer and
     // reported as a compile time error.
     analysis.calls.add(node.staticElement);
   }
 }