Add tree shaker support for setters and field writes.

pkg/analyzer2dart/test/tree_shaker_test.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.
 
 import 'mock_sdk.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:compiler/implementation/dart2jslib.dart' show NullSink;
 import 'package:unittest/unittest.dart';
 
 import '../lib/src/closed_world.dart';
 import '../lib/src/driver.dart';
 
 main() {
   test('Toplevel function', () {
     var helper = new TreeShakerTestHelper('''
 main() {
   foo();
 }
 foo() {
 }
 ''');
     helper.assertHasFunction('main');
     helper.assertHasFunction('foo');
   });
 
-  test('Toplevel field access', () {
+  test('Toplevel field read', () {
     var helper = new TreeShakerTestHelper('''
 main() {
   return foo;
 }
 var foo;
 var bar;
 ''');
     helper.assertHasFunction('main');
     helper.assertHasVariable('foo');
     helper.assertNoVariable('bar');
   });
 
+  test('Toplevel field write', () {
+    var helper = new TreeShakerTestHelper('''
+main() {
+  foo = 1;
+}
+var foo;
+var bar;
+''');
+    helper.assertHasFunction('main');
+    helper.assertHasVariable('foo');
+    helper.assertNoVariable('bar');
+  });
+
   test('Toplevel field invocation', () {
     var helper = new TreeShakerTestHelper('''
 main() {
   return foo();
 }
 var foo;
 var bar;
 ''');
     helper.assertHasFunction('main');
     helper.assertHasVariable('foo');
@@ skipping 85 matching lines @@
 ''');
     helper.assertHasMethod('A.m1');
     helper.assertHasMethod('A.m2');
   });
 
   test('Getter usage', () {
     var helper = new TreeShakerTestHelper('''
 class A {
   get g1 => null;
   get g2 => null;
+  set g1(x) {}
+  set g2(x) {}
 }
 class B {
   get g1 => null;
   get g2 => null;
+  set g1(x) {}
+  set g2(x) {}
 }
 main() {
   new A().g1;
 }
 ''');
     helper.assertHasGetter('A.g1');
     helper.assertNoGetter('A.g2');
     helper.assertNoGetter('B.g1');
     helper.assertNoGetter('B.g2');
+    helper.assertNoSetter('A.g1');
+    helper.assertNoSetter('A.g2');
+    helper.assertNoSetter('B.g1');
+    helper.assertNoSetter('B.g2');
+  });
+
+  test('Setter usage', () {
+    var helper = new TreeShakerTestHelper('''
+class A {
+  get g1 => null;
+  get g2 => null;
+  set g1(x) {}
+  set g2(x) {}
+}
+class B {
+  get g1 => null;
+  get g2 => null;
+  set g1(x) {}
+  set g2(x) {}
+}
+main() {
+  new A().g1 = 1;
+}
+''');
+    helper.assertHasSetter('A.g1');
+    helper.assertNoSetter('A.g2');
+    helper.assertNoSetter('B.g1');
+    helper.assertNoSetter('B.g2');
+    helper.assertNoGetter('A.g1');
+    helper.assertNoGetter('A.g2');
+    helper.assertNoGetter('B.g1');
+    helper.assertNoGetter('B.g2');
   });
 
-  test('Field access', () {
+  test('Field read', () {
     var helper = new TreeShakerTestHelper('''
 class A {
   var f1;
   var f2;
 }
 class B {
   var f1;
   var f2;
 }
 main() {
   new A().f1;
 }
 ''');
     helper.assertHasField('A.f1');
     helper.assertNoField('A.f2');
     helper.assertNoField('B.f1');
     helper.assertNoField('B.f2');
   });
 
+  test('Field write', () {
+    var helper = new TreeShakerTestHelper('''
+class A {
+  var f1;
+  var f2;
+}
+class B {
+  var f1;
+  var f2;
+}
+main() {
+  new A().f1 = 1;
+}
+''');
+    helper.assertHasField('A.f1');
+    helper.assertNoField('A.f2');
+    helper.assertNoField('B.f1');
+    helper.assertNoField('B.f2');
+  });
+
   test('Ordinary constructor with initializer list', () {
     var helper = new TreeShakerTestHelper('''
 class A {
   A() : x = f();
   var x;
   foo() {}
 }
 f() {}
 main() {
   new A().foo();
@@ skipping 76 matching lines @@
    * Methods contained in [world], indexed by className.methodName.
    */
   Map<String, MethodDeclaration> methods = <String, MethodDeclaration>{};
 
   /**
    * Getters contained in [world], indexed by className.propertyName.
    */
   Map<String, MethodDeclaration> getters = <String, MethodDeclaration>{};
 
   /**
+   * Setters contained in [world], indexed by className.propertyName.
+   */
+  Map<String, MethodDeclaration> setters = <String, MethodDeclaration>{};
+
+  /**
    * Fields contained in [world], indexed by className.fieldName.
    */
   Map<String, VariableDeclaration> fields = <String, VariableDeclaration>{};
 
   /**
    * Top level variables contained in [world], indexed by name.
    */
   Map<String, VariableDeclaration> variables = <String, VariableDeclaration>{};
 
   /**
@@ skipping 26 matching lines @@
         expect(declaration.element, equals(element));
         methods['${element.enclosingElement.name}.${element.name}'] =
             declaration;
       } else if (element is PropertyAccessorElement) {
         MethodDeclaration declaration = node as MethodDeclaration;
         expect(declaration, isNotNull);
         expect(declaration.element, equals(element));
         if (declaration.isGetter) {
           getters['${element.enclosingElement.name}.${element.name}'] =
               declaration;
+        } else if (declaration.isSetter) {
+          // element.name uses the convention that setter names end in '='.
+          // Strip off the '=' to avoid confusion in writing the tests.

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

We could use element.displayName instead.

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

Done.

+          String setterName =
+              '${element.enclosingElement.name}.${element.name}';
+          assert(setterName.endsWith('='));
+          setters[setterName.substring(0, setterName.length - 1)] =
+              declaration;
         } else {
-          // TODO(paulberry): handle setters.
-          throw new UnimplementedError();
+          fail('Unexpected property accessor (neither getter nor setter)');
         }
       }
     });
     world.instantiatedClasses.forEach(
         (ClassElement element, ClassDeclaration declaration) {
       expect(declaration, isNotNull);
       expect(declaration.element, equals(element));
       instantiatedClasses[element.name] = declaration;
     });
     world.fields.forEach(
@@ skipping 32 matching lines @@
   }
 
   /**
    * Asserts that [world] contains a getter with the given qualified name.
    */
   void assertHasGetter(String qualifiedName) {
     expect(getters, contains(qualifiedName));
   }
 
   /**
+   * Asserts that [world] contains a setter with the given qualified name.
+   */
+  void assertHasSetter(String qualifiedName) {
+    expect(setters, contains(qualifiedName));
+  }
+
+  /**
    * Asserts that [world] instantiates a class with the given name.
    */
   void assertHasInstantiatedClass(String name) {
     expect(instantiatedClasses, contains(name));
   }
 
   /**
    * Asserts that [world] contains a method with the given qualified name.
    *
    * [qualifiedName] - the qualified name in form 'className.methodName'.
@@ skipping 28 matching lines @@
 
   /**
    * Asserts that [world] doesn't contain a getter with the given qualified
    * name.
    */
   void assertNoGetter(String qualifiedName) {
     expect(getters, isNot(contains(qualifiedName)));
   }
 
   /**
+   * Asserts that [world] doesn't contain a setter with the given qualified
+   * name.
+   */
+  void assertNoSetter(String qualifiedName) {
+    expect(setters, isNot(contains(qualifiedName)));
+  }
+
+  /**
    * Asserts that [world] doesn't instantiate a class with the given name.
    */
   void assertNoInstantiatedClass(String name) {
     expect(instantiatedClasses, isNot(contains(name)));
   }
 
   /**
    * Asserts that [world] doesn't contain a method with the given qualified
    * name.
    *
    * [qualifiedName] - the qualified name in form 'className.methodName'.
    */
   void assertNoMethod(String qualifiedName) {
     expect(methods, isNot(contains(qualifiedName)));
   }
 }