Support assignment of locals 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';
@@ skipping 189 matching lines @@
         fields);
     methods.forEach(_addElement);
     accessors.forEach(_addElement);
     fields.forEach(_addElement);
   }
 
   ClosedWorld shake() {
     _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: '
                 '$element (${element.runtimeType})');
       }
     }
-    print('Tree shaking done');
     return _world;
   }
 }
 
 class TreeShakingVisitor extends SemanticVisitor {
   final MethodAnalysis analysis;
 
   TreeShakingVisitor(this.analysis);
 
   Source get currentSource => analysis.declaration.element.source;
@@ skipping 38 matching lines @@
 
   @override
   void visitStaticFieldInvocation(MethodInvocation node,
       AccessSemantics semantics) {
     // Invocation of a static field.
     analysis.accesses.add(semantics.element);
     analysis.invokes.add(createSelectorFromMethodInvocation(
         node.argumentList, 'call'));
   }
 
+  @override
   void visitStaticMethodInvocation(MethodInvocation node,
       AccessSemantics semantics) {
     analysis.calls.add(semantics.element);
   }
 
+  @override
   void visitStaticPropertyInvocation(MethodInvocation node,
       AccessSemantics semantics) {
     // Invocation of a property.  TODO(paulberry): handle this.
     super.visitStaticPropertyInvocation(node, semantics);
   }
 
-  void visitDynamicAccess(AstNode node, AccessSemantics semantics) {
+  void handleDynamicAccess(AccessSemantics semantics) {
     if (semantics.isRead) {
       analysis.invokes.add(
           new Selector.getter(semantics.identifier.name, null));
     }
     if (semantics.isWrite) {
       // Selector.setter constructor uses the convention that setter names
       // don't end in '='.
       analysis.invokes.add(
           new Selector.setter(semantics.identifier.name, null));
     }
   }
 
+  @override
+  void visitDynamicAccess(AstNode node, AccessSemantics semantics) {
+    handleDynamicAccess(semantics);
+  }
+
+  @override
   void visitLocalFunctionAccess(AstNode node, AccessSemantics semantics) {
     // Locals don't need to be tree shaken.
   }
 
+  @override
   void visitLocalVariableAccess(AstNode node, AccessSemantics semantics) {
     // Locals don't need to be tree shaken.
   }
 
+  @override
   void visitParameterAccess(AstNode node, AccessSemantics semantics) {
     // Locals don't need to be tree shaken.
   }
 
+  @override
   void visitStaticFieldAccess(AstNode node, AccessSemantics semantics) {
     analysis.accesses.add(semantics.element);
   }
 
+  @override
   void visitStaticMethodAccess(AstNode node, AccessSemantics semantics) {
     // Method tear-off.  TODO(paulberry): implement.
     super.visitStaticMethodAccess(node, semantics);
   }
 
+  @override
   void visitStaticPropertyAccess(AstNode node, AccessSemantics semantics) {
     // TODO(paulberry): implement.
     super.visitStaticPropertyAccess(node, semantics);
   }
 
   @override
   void visitConstructorDeclaration(ConstructorDeclaration node) {
     // TODO(paulberry): handle parameter list.
     node.initializers.accept(this);
     node.body.accept(this);
@@ skipping 18 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);
   }
+
+  @override
+  void handleAssignmentExpression(AssignmentExpression node) {
+    // Don't special-case assignment expressions.
+  }
 }