Add sharedfrontend package

pkg/analyzer2dart/test/identifier_semantics_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 'package:analyzer/analyzer.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer2dart/src/identifier_semantics.dart';
 import 'package:unittest/unittest.dart';
+import 'package:sharedfrontend/src/access_semantics.dart';
 
 import 'mock_sdk.dart';
 
 main() {
   test('Call function defined at top level', () {
     Helper helper = new Helper('''
 g() {}
 
 f() {
   g();
@@ skipping 2264 matching lines @@
     int count = 0;
     visitor.onAccess = (AstNode node, AccessSemantics semantics) {
       count++;
       expect(node.toSource(), equals(expectedSource));
       expect(semantics.kind, equals(AccessKind.DYNAMIC));
       if (expectedTarget == null) {
         expect(semantics.target, isNull);
       } else {
         expect(semantics.target.toSource(), equals(expectedTarget));
       }
-      expect(semantics.identifier.name, equals(expectedName));
+      expect(semantics.name, equals(expectedName));
       expect(semantics.element, isNull);
       expect(semantics.classElement, isNull);
       expect(semantics.isRead, equals(isRead));
       expect(semantics.isWrite, equals(isWrite));
       expect(semantics.isInvoke, equals(isInvoke));
     };
     libraryElement.unit.accept(visitor);
     expect(count, equals(1));
   }
 
   /**
    * Verify that the node represented by [expectedSource] is classified as
    * a local function invocation.
    */
   void checkLocalFunction(String expectedSource, String expectedName,
       {bool isRead: false, bool isWrite: false, bool isInvoke: false}) {
     TestVisitor visitor = new TestVisitor();
     int count = 0;
     visitor.onAccess = (AstNode node, AccessSemantics semantics) {
       count++;
       expect(node.toSource(), equals(expectedSource));
       expect(semantics.kind, equals(AccessKind.LOCAL_FUNCTION));
-      expect(semantics.identifier.name, equals(expectedName));
-      expect(semantics.element.displayName, equals(expectedName));
+      expect(semantics.name, equals(expectedName));
+      expect(displayName(semantics.element), equals(expectedName));
       expect(semantics.classElement, isNull);
       expect(semantics.target, isNull);
       expect(semantics.isRead, equals(isRead));
       expect(semantics.isWrite, equals(isWrite));
       expect(semantics.isInvoke, equals(isInvoke));
     };
     libraryElement.unit.accept(visitor);
     expect(count, equals(1));
   }
 
@@ skipping 49 matching lines @@
    */
   void checkStaticField(String expectedSource, String expectedClass,
       String expectedName, {bool isRead: false, bool isWrite: false, bool isInvoke:
       false}) {
     TestVisitor visitor = new TestVisitor();
     int count = 0;
     visitor.onAccess = (Expression node, AccessSemantics semantics) {
       count++;
       expect(node.toSource(), equals(expectedSource));
       expect(semantics.kind, equals(AccessKind.STATIC_FIELD));
-      expect(semantics.identifier.name, equals(expectedName));
-      expect(semantics.element.displayName, equals(expectedName));
+      expect(semantics.name, equals(expectedName));
+      expect(displayName(semantics.element), equals(expectedName));
       if (expectedClass == null) {
         expect(semantics.classElement, isNull);
       } else {
         expect(semantics.classElement, isNotNull);
-        expect(semantics.classElement.displayName, equals(expectedClass));
+        expect(displayName(semantics.classElement), equals(expectedClass));
       }
       expect(semantics.target, isNull);
       expect(semantics.isRead, equals(isRead));
       expect(semantics.isWrite, equals(isWrite));
       expect(semantics.isInvoke, equals(isInvoke));
     };
     libraryElement.unit.accept(visitor);
     expect(count, equals(1));
   }
 
   /**
    * Verify that the node represented by [expectedSource] is classified as
    * a static method.
    */
   void checkStaticMethod(String expectedSource, String expectedClass,
       String expectedName, bool defined, {bool isRead: false, bool isWrite: false,
       bool isInvoke: false}) {
     TestVisitor visitor = new TestVisitor();
     int count = 0;
     visitor.onAccess = (AstNode node, AccessSemantics semantics) {
       count++;
       expect(node.toSource(), equals(expectedSource));
       expect(semantics.kind, equals(AccessKind.STATIC_METHOD));
-      expect(semantics.identifier.name, equals(expectedName));
+      expect(semantics.name, equals(expectedName));
       if (expectedClass == null) {
         expect(semantics.classElement, isNull);
         if (defined) {
           expect(semantics.element, new isInstanceOf<FunctionElement>());
         }
       } else {
         expect(semantics.classElement, isNotNull);
-        expect(semantics.classElement.displayName, equals(expectedClass));
+        expect(displayName(semantics.classElement), equals(expectedClass));
         if (defined) {
           expect(semantics.element, new isInstanceOf<MethodElement>());
         }
       }
       if (defined) {
-        expect(semantics.element.displayName, equals(expectedName));
+        expect(displayName(semantics.element), equals(expectedName));
       } else {
         expect(semantics.element, isNull);
       }
       expect(semantics.target, isNull);
       expect(semantics.isRead, equals(isRead));
       expect(semantics.isWrite, equals(isWrite));
       expect(semantics.isInvoke, equals(isInvoke));
     };
     libraryElement.unit.accept(visitor);
     expect(count, equals(1));
   }
 
   /**
    * Verify that the node represented by [expectedSource] is classified as
    * a static property access.
    */
   void checkStaticProperty(String expectedSource, String expectedClass,
       String expectedName, bool defined, {bool isRead: false, bool isWrite: false,
       bool isInvoke: false}) {
     TestVisitor visitor = new TestVisitor();
     int count = 0;
     visitor.onAccess = (Expression node, AccessSemantics semantics) {
       count++;
       expect(node.toSource(), equals(expectedSource));
       expect(semantics.kind, equals(AccessKind.STATIC_PROPERTY));
-      expect(semantics.identifier.name, equals(expectedName));
+      expect(semantics.name, equals(expectedName));
       if (expectedClass == null) {
         expect(semantics.classElement, isNull);
       } else {
         expect(semantics.classElement, isNotNull);
-        expect(semantics.classElement.displayName, equals(expectedClass));
+        expect(displayName(semantics.classElement), equals(expectedClass));
       }
       if (defined) {
-        expect(semantics.element.displayName, equals(expectedName));
+        expect(displayName(semantics.element), equals(expectedName));
       } else {
         expect(semantics.element, isNull);
       }
       expect(semantics.target, isNull);
       expect(semantics.isRead, equals(isRead));
       expect(semantics.isWrite, equals(isWrite));
       expect(semantics.isInvoke, equals(isInvoke));
     };
     libraryElement.unit.accept(visitor);
     expect(count, equals(1));
@@ skipping 45 matching lines @@
   }
 
   @override
   visitSimpleIdentifier(SimpleIdentifier node) {
     AccessSemantics semantics = node.accept(ACCESS_SEMANTICS_VISITOR);
     if (semantics != null) {
       onAccess(node, semantics);
     }
   }
 }
+
+// TODO(johnniwinther): Remove this when the semantics of element names have
+// been resolved.
+/// Helper methods for accessing the [displayName] method without warning.
+String displayName(element) => element.displayName;