Support assignment of locals in analyzer2dart.

pkg/analyzer2dart/lib/src/semantic_visitor.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.semantic_visitor;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/source.dart';
 
 import 'util.dart';
@@ skipping 63 matching lines @@
   @override
   R visitMethodInvocation(MethodInvocation node) {
     if (node.target != null) {
       node.target.accept(this);
     }
     node.argumentList.accept(this);
     return handleMethodInvocation(node);
   }
 
   R handleMethodInvocation(MethodInvocation node) {
-    AccessSemantics semantics = classifyMethodInvocation(node);
+    AccessSemantics semantics = node.accept(ACCESS_SEMANTICS_VISITOR);
     switch (semantics.kind) {
       case AccessKind.DYNAMIC:
         return visitDynamicInvocation(node, semantics);
       case AccessKind.LOCAL_FUNCTION:
         return visitLocalFunctionInvocation(node, semantics);
       case AccessKind.LOCAL_VARIABLE:
         return visitLocalVariableInvocation(node, semantics);
       case AccessKind.PARAMETER:
         return visitParameterInvocation(node, semantics);
       case AccessKind.STATIC_FIELD:
@@ skipping 11 matching lines @@
 
   @override
   R visitPropertyAccess(PropertyAccess node) {
     if (node.target != null) {
       node.target.accept(this);
     }
     return handlePropertyAccess(node);
   }
 
   R handlePropertyAccess(PropertyAccess node) {
-    return _handlePropertyAccess(node, classifyPropertyAccess(node));
+    return _handlePropertyAccess(node, node.accept(ACCESS_SEMANTICS_VISITOR));
   }
 
   @override
   R visitPrefixedIdentifier(PrefixedIdentifier node) {
     node.prefix.accept(this);
     return handlePrefixedIdentifier(node);
   }
 
   R handlePrefixedIdentifier(PrefixedIdentifier node) {
-    return _handlePropertyAccess(node, classifyPrefixedIdentifier(node));
+    return _handlePropertyAccess(node, node.accept(ACCESS_SEMANTICS_VISITOR));
   }
 
   @override
   R visitSimpleIdentifier(SimpleIdentifier node) {
-    AccessSemantics semantics = classifySimpleIdentifier(node);
+    AccessSemantics semantics = node.accept(ACCESS_SEMANTICS_VISITOR);
     if (semantics != null) {
       return _handlePropertyAccess(node, semantics);
     } else {
       return null;
     }
   }
 
   R visitDynamicAccess(AstNode node, AccessSemantics semantics) {
     return giveUp(node, 'visitDynamicAccess of $semantics');
   }
@@ skipping 37 matching lines @@
       case AccessKind.STATIC_METHOD:
         return visitStaticMethodAccess(node, semantics);
       case AccessKind.STATIC_PROPERTY:
         return visitStaticPropertyAccess(node, semantics);
       default:
         // Unexpected access kind.
         return giveUp(node,
             'Unexpected ${semantics} in _handlePropertyAccess.');
     }
   }
+
+  // TODO(johnniwinther,paulberry): Is this a real thing?

[Paul Berry, 2014/10/27 14:15:56]

This will only happen if the call

  node.leftHandSide.accept(ACCESS_SEMANTICS_VISITOR);

(below on line 238) returns null.  For an error-free program, I believe that can
only happen if the LHS of the assignment is an array indexing operation, i.e.:

  x[i] = y;

I think I'd prefer to handle this by either (a) adding a new AccessSemanticsKind
to represent the invocation of an index operator, or (b) simply handling it as a
special case in handleAssignmentExpression().

I'm not sure which of these two choices would be better.

[Johnni Winther, 2014/10/27 14:26:18]

Ahh. We need an AccessSemantics for index operations anyway. Adding a
TODO+giveup instead.

+  R visitDynamicAssignment(AssignmentExpression node) {
+    return giveUp(node, 'visitDynamicAssignment');
+  }
+
+  R visitDynamicPropertyAssignment(AssignmentExpression node,
+                                   AccessSemantics semantics) {
+    return giveUp(node, 'visitDynamicPropertyAssignment of $semantics');
+  }
+
+  R visitLocalFunctionAssignment(AssignmentExpression node,
+                                 AccessSemantics semantics) {
+    return giveUp(node, 'visitLocalFunctionAssignment of $semantics');
+  }
+
+  R visitLocalVariableAssignment(AssignmentExpression node,
+                                 AccessSemantics semantics) {
+    return giveUp(node, 'visitLocalVariableAssignment of $semantics');
+  }
+
+  R visitParameterAssignment(AssignmentExpression node,
+                             AccessSemantics semantics) {
+    return giveUp(node, 'visitParameterAssignment of $semantics');
+  }
+
+  R visitStaticFieldAssignment(AssignmentExpression node,
+                               AccessSemantics semantics) {
+    return giveUp(node, 'visitStaticFieldAssignment of $semantics');
+  }
+
+  R visitStaticMethodAssignment(AssignmentExpression node,
+                                AccessSemantics semantics) {
+    return giveUp(node, 'visitStaticMethodAssignment of $semantics');
+  }
+
+  R visitStaticPropertyAssignment(AssignmentExpression node,
+                                  AccessSemantics semantics) {
+    return giveUp(node, 'visitStaticPropertyAssignment of $semantics');
+  }
+
+  @override
+  R visitAssignmentExpression(AssignmentExpression node) {
+    super.visitAssignmentExpression(node);
+    return handleAssignmentExpression(node);
+  }
+
+  R handleAssignmentExpression(AssignmentExpression node) {
+    AccessSemantics semantics =
+        node.leftHandSide.accept(ACCESS_SEMANTICS_VISITOR);
+    if (semantics == null) {
+      return visitDynamicAssignment(node);
+    } else {
+      switch (semantics.kind) {
+        case AccessKind.DYNAMIC:
+          return visitDynamicPropertyAssignment(node, semantics);
+        case AccessKind.LOCAL_FUNCTION:
+          return visitLocalFunctionAssignment(node, semantics);
+        case AccessKind.LOCAL_VARIABLE:
+          return visitLocalVariableAssignment(node, semantics);
+        case AccessKind.PARAMETER:
+          return visitParameterAssignment(node, semantics);
+        case AccessKind.STATIC_FIELD:
+          return visitStaticFieldAssignment(node, semantics);
+        case AccessKind.STATIC_METHOD:
+          return visitStaticMethodAssignment(node, semantics);
+        case AccessKind.STATIC_PROPERTY:
+          return visitStaticPropertyAssignment(node, semantics);
+        default:
+          // Unexpected access kind.
+          return giveUp(node,
+              'Unexpected ${semantics} in _handlePropertyAccess.');
+      }
+    }
+  }
 }