Support static field access in analyzer2dart.

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', () {
+    var helper = new TreeShakerTestHelper('''
+main() {
+  return foo;
+}
+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');
+    helper.assertNoVariable('bar');
+  });

[Paul Berry, 2014/09/26 16:42:39]

We should probably also test that this drags a "call" selector into the world. 
I think we could accomplish that with something like:

var helper = new TreeshakerTestHelper('''
class A {
  void call() {}
  void baz() {}
}
main() {
  new A();
  return foo;
}
var foo;
var bar;
''');
helper.assertHasFunction('main');
helper.assertHasVariable('foo');
helper.assertNoVariable('bar');
helper.assertHasInstantiatedClass('A');
helper.assertHasMethod('A.call');
helper.assertNoMethod('A.baz');

[Johnni Winther, 2014/09/29 13:07:25]

Added with 'foo()' instead of 'return foo'.

+
   test('Class instantiation', () {
     var helper = new TreeShakerTestHelper('''
 main() {
   var x = new A();
 }
 class A {}
 class B {}
 ''');
     helper.assertHasInstantiatedClass('A');
     helper.assertNoInstantiatedClass('B');
@@ skipping 119 matching lines @@
    * Getters contained in [world], indexed by className.propertyName.
    */
   Map<String, MethodDeclaration> getters = <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>{};
+
+  /**
    * Classes instantiated in [world], indexed by name.
    */
   Map<String, ClassDeclaration> instantiatedClasses = <String,
       ClassDeclaration>{};
 
   /**
    * Create a TreeShakerTestHelper based on the given file contents.
    */
   TreeShakerTestHelper(String contents) {
     MemoryResourceProvider provider = new MemoryResourceProvider();
@@ skipping 34 matching lines @@
       expect(declaration, isNotNull);
       expect(declaration.element, equals(element));
       instantiatedClasses[element.name] = declaration;
     });
     world.fields.forEach(
         (FieldElement element, VariableDeclaration declaration) {
       expect(declaration, isNotNull);
       expect(declaration.element, equals(element));
       fields['${element.enclosingElement.name}.${element.name}'] = declaration;
     });
+    world.variables.forEach(
+        (TopLevelVariableElement element, VariableDeclaration declaration) {
+      expect(declaration, isNotNull);
+      expect(declaration.element, equals(element));
+      variables['${element.name}'] = declaration;
+    });
   }
 
   /**
    * Asserts that [world] contains a field with the given qualified name.
    */
   void assertHasField(String qualifiedName) {
     expect(fields, contains(qualifiedName));
   }
 
   /**
+   * Asserts that [world] contains a top level variable with the given name.
+   */
+  void assertHasVariable(String name) {
+    expect(variables, contains(name));
+  }
+
+  /**
    * Asserts that [world] contains a top-level function with the given name.
    */
   void assertHasFunction(String name) {
     expect(functions, contains(name));
   }
 
   /**
    * Asserts that [world] contains a getter with the given qualified name.
    */
   void assertHasGetter(String qualifiedName) {
@@ skipping 18 matching lines @@
 
   /**
    * Asserts that [world] doesn't contain a field with the given qualified
    * name.
    */
   void assertNoField(String qualifiedName) {
     expect(fields, isNot(contains(qualifiedName)));
   }
 
   /**
+   * Asserts that [world] doesn't contain a top level variable with the given
+   * name.
+   */
+  void assertNoVariable(String name) {
+    expect(variables, isNot(contains(name)));
+  }
+
+  /**
    * Asserts that [world] doesn't contain a top-level function with the given
    * name.
    */
   void assertNoFunction(String name) {
     expect(functions, isNot(contains(name)));
   }
 
   /**
    * Asserts that [world] doesn't contain a getter with the given qualified
    * name.
@@ skipping 12 matching lines @@
   /**
    * 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)));
   }
 }