Support static field access in analyzer2dart.

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';
+import 'package:analyzer/src/generated/source.dart';
 import 'package:compiler/implementation/universe/universe.dart';
 
 import 'closed_world.dart';
+import 'util.dart';
+import 'semantic_visitor.dart';
 import 'package:analyzer2dart/src/identifier_semantics.dart';
 
 /**
  * The result of performing local reachability analysis on a method.
  */
 class MethodAnalysis {
   /**
    * The AST for the method.
    */
   final Declaration declaration;
 
   /**
    * The functions statically called by the method.
    */
   final List<ExecutableElement> calls = <ExecutableElement>[];
 
   /**
+   * The fields and top-level variables statically accessed by the method.
+   */
+  // TODO(johnniwinther): Should we split this into reads and writes?
+  final List<PropertyInducingElement> accesses = <PropertyInducingElement>[];
+
+  /**
    * The selectors used by the method to perform dynamic invocation.
    */
   final List<Selector> invokes = <Selector>[];
 
   /**
    * The classes that are instantiated by the method.
    */
   final List<ClassElement> instantiates = <ClassElement>[];
 
   MethodAnalysis(this.declaration);
@@ skipping 126 matching lines @@
     _addElement(_world.mainFunction);
     while (_queue.isNotEmpty) {
       Element element = _queue.removeLast();
       print('Tree shaker handling $element');
       if (element is ExecutableElement) {
         MethodAnalysis analysis = _localComputer.analyzeMethod(element);
         _world.executableElements[element] = analysis.declaration;
         analysis.calls.forEach(_addElement);
         analysis.invokes.forEach(_addSelector);
         analysis.instantiates.forEach(_addElement);
+        analysis.accesses.forEach(_addElement);
       } else if (element is ClassElement) {
         ClassAnalysis analysis = _localComputer.analyzeClass(element);
         _world.instantiatedClasses[element] = analysis.declaration;
         for (Selector selector in _selectors) {
           _matchClassToSelector(element, selector);
         }
       } else if (element is FieldElement) {
         VariableDeclaration declaration = element.node;
         _world.fields[element] = declaration;
+      } else if (element is TopLevelVariableElement) {
+        VariableDeclaration declaration = element.node;
+        _world.variables[element] = declaration;
       } else {
-        throw new Exception('Unexpected element type while tree shaking');
+        throw new Exception(
+            'Unexpected element type while tree shaking: '
+            '$element (${element.runtimeType})');
       }
     }
     print('Tree shaking done');
     return _world;
   }
 }
 
-Selector createSelectorFromMethodInvocation(MethodInvocation node) {
-  int arity = 0;
-  List<String> namedArguments = <String>[];
-  for (var x in node.argumentList.arguments) {
-    if (x is NamedExpression) {
-      namedArguments.add(x.name.label.name);
-    } else {
-      arity++;
-    }
-  }
-  return new Selector.call(node.methodName.name, null, arity, namedArguments);
-}
-
-class TreeShakingVisitor extends RecursiveAstVisitor {
+class TreeShakingVisitor extends SemanticVisitor {
   final MethodAnalysis analysis;
 
   TreeShakingVisitor(this.analysis);
 
+  Source get currentSource => analysis.declaration.element.source;
+
   @override
   void visitInstanceCreationExpression(InstanceCreationExpression node) {
     ConstructorElement staticElement = node.staticElement;
     if (staticElement != null) {
       // TODO(paulberry): Really we should enqueue the constructor, and then
       // when we visit it add the class to the class bucket.
       ClassElement classElement = staticElement.enclosingElement;
       analysis.instantiates.add(classElement);
     } else {
       // TODO(paulberry): deal with this situation.  This can happen, for
       // example, in the case "main() => new Unresolved();" (which is a
       // warning, not an error).
     }
     super.visitInstanceCreationExpression(node);
   }
 
   @override
-  void visitMethodInvocation(MethodInvocation node) {
-    if (node.target != null) {
-      node.target.accept(this);
+  void visitDynamicInvocation(MethodInvocation node,
+                              AccessSemantics semantics) {
+    analysis.invokes.add(
+        createSelectorFromMethodInvocation(node, node.methodName.name));
+  }
+
+  @override
+  void visitLocalFunctionInvocation(MethodInvocation node,
+                                    AccessSemantics semantics) {
+    // Locals don't need to be tree shaken.
+  }
+
+  @override
+  void visitLocalVariableInvocation(MethodInvocation node,
+                                    AccessSemantics semantics) {
+    // Locals don't need to be tree shaken.
+  }
+
+  @override
+  void visitParameterInvocation(MethodInvocation node,
+                                AccessSemantics semantics) {
+    // Locals don't need to be tree shaken.
+  }
+
+  @override
+  void visitStaticFieldInvocation(MethodInvocation node,
+                                  AccessSemantics semantics) {
+    // Invocation of a static field.
+    analysis.accesses.add(semantics.element);
+    analysis.invokes.add(
+      createSelectorFromMethodInvocation(node, 'call'));
+  }
+
+  void visitStaticMethodInvocation(MethodInvocation node,
+                                   AccessSemantics semantics) {
+    analysis.calls.add(semantics.element);
+  }
+
+  void visitStaticPropertyInvocation(MethodInvocation node,
+                                     AccessSemantics semantics) {
+    // 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));
     }
-    node.argumentList.accept(this);
-    AccessSemantics semantics = classifyMethodInvocation(node);
-    switch (semantics.kind) {
-      case AccessKind.DYNAMIC:
-        analysis.invokes.add(createSelectorFromMethodInvocation(node));
-        break;
-      case AccessKind.LOCAL_FUNCTION:
-      case AccessKind.LOCAL_VARIABLE:
-      case AccessKind.PARAMETER:
-        // Locals don't need to be tree shaken.
-        break;
-      case AccessKind.STATIC_FIELD:
-        // Invocation of a field.  TODO(paulberry): handle this.
-        throw new UnimplementedError();
-      case AccessKind.STATIC_METHOD:
-        analysis.calls.add(semantics.element);
-        break;
-      case AccessKind.STATIC_PROPERTY:
-        // Invocation of a property.  TODO(paulberry): handle this.
-        throw new UnimplementedError();
-      default:
-        // Unexpected access kind.
-        throw new UnimplementedError();
+    if (semantics.isWrite) {
+      // TODO(paulberry): implement.
+      return giveUp(node, '_handlePropertyAccess of ${semantics}.');
     }
   }
 
-  @override
-  void visitPropertyAccess(PropertyAccess node) {
-    if (node.target != null) {
-      node.target.accept(this);
-    }
-    _handlePropertyAccess(classifyPropertyAccess(node));
+  void visitLocalFunctionAccess(AstNode node, AccessSemantics semantics) {
+    // Locals don't need to be tree shaken.
   }
 
-  @override
-  visitPrefixedIdentifier(PrefixedIdentifier node) {
-    node.prefix.accept(this);
-    _handlePropertyAccess(classifyPrefixedIdentifier(node));
+  void visitLocalVariableAccess(AstNode node, AccessSemantics semantics) {
+    // Locals don't need to be tree shaken.
   }
 
-  @override
-  visitSimpleIdentifier(SimpleIdentifier node) {
-    AccessSemantics semantics = classifySimpleIdentifier(node);
-    if (semantics != null) {
-      _handlePropertyAccess(semantics);
-    }
+  void visitParameterAccess(AstNode node, AccessSemantics semantics) {
+    // Locals don't need to be tree shaken.
   }
 
-  void _handlePropertyAccess(AccessSemantics semantics) {
-    switch (semantics.kind) {
-      case AccessKind.DYNAMIC:
-        if (semantics.isRead) {
-          analysis.invokes.add(
-              new Selector.getter(semantics.identifier.name, null));
-        }
-        if (semantics.isWrite) {
-          // TODO(paulberry): implement.
-          throw new UnimplementedError();
-        }
-        break;
-      case AccessKind.LOCAL_FUNCTION:
-      case AccessKind.LOCAL_VARIABLE:
-      case AccessKind.PARAMETER:
-        // Locals don't need to be tree shaken.
-        break;
-      case AccessKind.STATIC_FIELD:
-        // TODO(paulberry): implement.
-        throw new UnimplementedError();
-      case AccessKind.STATIC_METHOD:
-        // Method tear-off.  TODO(paulberry): implement.
-        break;
-      case AccessKind.STATIC_PROPERTY:
-        // TODO(paulberry): implement.
-        throw new UnimplementedError();
-      default:
-        // Unexpected access kind.
-        throw new UnimplementedError();
-    }
+  void visitStaticFieldAccess(AstNode node, AccessSemantics semantics) {
+    analysis.accesses.add(semantics.element);
+  }
+
+  void visitStaticMethodAccess(AstNode node, AccessSemantics semantics) {
+    // Method tear-off.  TODO(paulberry): implement.
+    super.visitStaticMethodAccess(node, semantics);
+  }
+
+  void visitStaticPropertyAccess(AstNode node, AccessSemantics semantics) {
+    // TODO(paulberry): implement.
+    super.visitStaticPropertyAccess(node, semantics);
   }
 }