Add SExpression test and share tests between dart2dart and 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 59 matching lines @@
                                   AccessSemantics semantics) {
     return giveUp(node, 'visitStaticPropertyInvocation of $semantics');
   }
 
   @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);
     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:
         return visitStaticFieldInvocation(node, semantics);
       case AccessKind.STATIC_METHOD:
         return visitStaticMethodInvocation(node, semantics);
       case AccessKind.STATIC_PROPERTY:
         return visitStaticPropertyInvocation(node, semantics);
       default:
         // Unexpected access kind.
         return giveUp(node,
             'Unexpected ${semantics} in visitMethodInvocation.');
     }
   }
 
   @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));
   }
 
   @override
   R visitPrefixedIdentifier(PrefixedIdentifier node) {
     node.prefix.accept(this);
+    return handlePrefixedIdentifier(node);
+  }
+
+  R handlePrefixedIdentifier(PrefixedIdentifier node) {
     return _handlePropertyAccess(node, classifyPrefixedIdentifier(node));
   }
 
   @override
   R visitSimpleIdentifier(SimpleIdentifier node) {
     AccessSemantics semantics = classifySimpleIdentifier(node);
     if (semantics != null) {
       return _handlePropertyAccess(node, semantics);
     } else {
       return null;
@@ skipping 44 matching lines @@
         return visitStaticMethodAccess(node, semantics);
       case AccessKind.STATIC_PROPERTY:
         return visitStaticPropertyAccess(node, semantics);
       default:
         // Unexpected access kind.
         return giveUp(node,
             'Unexpected ${semantics} in _handlePropertyAccess.');
     }
   }
 }