Add AccessSemantics support for calling typenames.

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:analyzer/file_system/memory_file_system.dart';
+
 import 'mock_sdk.dart';
-import 'package:analyzer/src/generated/sdk.dart';
-import 'package:analyzer/file_system/file_system.dart';
-import 'package:analyzer/src/generated/source.dart';
-import 'package:analyzer/src/generated/engine.dart';
-import 'package:analyzer/src/generated/element.dart';
-import 'package:analyzer/src/generated/source_io.dart';
-import 'package:analyzer/analyzer.dart';
-import 'package:analyzer2dart/src/identifier_semantics.dart';
 
 main() {
   test('Call function defined at top level', () {
     Helper helper = new Helper('''
 g() {}
 
 f() {
   g();
 }
 ''');
@@ skipping 532 matching lines @@
     Helper helper = new Helper('''
 h() => null;
 
 f() {
   return h().x();
 }
 ''');
     helper.checkDynamic('h().x()', 'h()', 'x', isInvoke: true);
   });
 
+  test('Call class defined at top level', () {
+    Helper helper = new Helper('''
+class A {}
+
+f() {
+  A();
+}
+''');
+    helper.checkTypeReference(
+        'A()',
+        'A',
+        AccessKind.TOPLEVEL_TYPE,
+        isInvoke: true);
+  });
+
+  test('Call class defined at top level via prefix', () {
+    Helper helper = new Helper('''
+import 'lib.dart' as l;
+
+f() {
+  l.A();
+}
+''');
+    helper.addFile('/lib.dart', '''
+library lib;
+
+class A;
+''');
+    helper.checkTypeReference(
+        'l.A()',
+        'A',
+        AccessKind.TOPLEVEL_TYPE,
+        isInvoke: true);
+  });
+
+  test('Call dynamic type undefined at toplevel', () {
+    Helper helper = new Helper('''
+f() {
+  dynamic();
+}
+''');
+    // Since it is legal to define a toplevel function or a class member called
+    // dynamic, "dynamic()" must be treated as a dynamic access to a function
+    // called "dynamic".
+    helper.checkDynamic('dynamic()', null, 'dynamic', isInvoke: true);
+  });
+
+  test('Call function typedef defined at top level', () {
+    Helper helper = new Helper('''
+typedef F();
+
+f() {
+  F();
+}
+''');
+    helper.checkTypeReference(
+        'F()',
+        'F',
+        AccessKind.TOPLEVEL_TYPE,
+        isInvoke: true);
+  });
+
+  test('Call function typedef defined at top level via prefix', () {
+    Helper helper = new Helper('''
+import 'lib.dart' as l;
+
+f() {
+  l.F();
+}
+''');
+    helper.addFile('/lib.dart', '''
+library lib;
+
+typedef F();
+''');
+    helper.checkTypeReference(
+        'l.F()',
+        'F',
+        AccessKind.TOPLEVEL_TYPE,
+        isInvoke: true);
+  });
+
+  test('Call mixin application defined at top level', () {
+    Helper helper = new Helper('''
+class A {}
+class B {}
+class C = A with B;
+
+f() {
+  C();
+}
+''');
+    helper.checkTypeReference(
+        'C()',
+        'C',
+        AccessKind.TOPLEVEL_TYPE,
+        isInvoke: true);
+  });
+
+  test('Call mixin application defined at top level via prefix', () {
+    Helper helper = new Helper('''
+import 'lib.dart' as l;
+
+f() {
+  l.C();
+}
+''');
+    helper.addFile('/lib.dart', '''
+library lib;
+
+class A;

[scheglov, 2014/12/18 21:19:35]

class A {}

[Paul Berry, 2014/12/18 21:56:58]

Done.

+class B;
+class C = A with B;
+''');
+    helper.checkTypeReference(
+        'l.C()',
+        'C',
+        AccessKind.TOPLEVEL_TYPE,
+        isInvoke: true);
+  });
+
+  test('Call type parameter of enclosing class', () {
+    Helper helper = new Helper('''
+class A<T, U> {
+  f() {
+    U();
+  }
+}
+''');
+    helper.checkTypeReference(
+        'U()',
+        'U',
+        AccessKind.TYPE_PARAMETER,
+        isInvoke: true);
+  });
+
   test('Get function defined at top level', () {
     Helper helper = new Helper('''
 g() {}
 
 f() {
   return g;
 }
 ''');
     helper.checkStaticMethod('g', null, 'g', true, isRead: true);
   });
@@ skipping 512 matching lines @@
 }
 ''');
     helper.checkDynamic('h().x', 'h()', 'x', isRead: true);
   });
 
   test('Get class defined at top level', () {
     Helper helper = new Helper('''
 class A {}
 var t = A;
 ''');
-    helper.checkTypeReference('A', 'A', AccessKind.TOPLEVEL_TYPE);
+    helper.checkTypeReference('A', 'A', AccessKind.TOPLEVEL_TYPE, isRead: true);
   });
 
   test('Get class defined at top level via prefix', () {
     Helper helper = new Helper('''
 import 'lib.dart' as l;
 
 var t = l.A;
 ''');
     helper.addFile('/lib.dart', '''
 library lib;
 
 class A;

[scheglov, 2014/12/18 21:19:35]

class A {}

[Paul Berry, 2014/12/18 21:56:58]

Done.

 ''');
-    helper.checkTypeReference('l.A', 'A', AccessKind.TOPLEVEL_TYPE);
+    helper.checkTypeReference(
+        'l.A',
+        'A',
+        AccessKind.TOPLEVEL_TYPE,
+        isRead: true);
   });
 
   test('Get dynamic type', () {
     Helper helper = new Helper('''
 var t = dynamic;
 ''');
-    helper.checkTypeReference('dynamic', 'dynamic', AccessKind.TOPLEVEL_TYPE);
+    helper.checkTypeReference(
+        'dynamic',
+        'dynamic',
+        AccessKind.TOPLEVEL_TYPE,
+        isRead: true);
   });
 
   test('Get function typedef defined at top level', () {
     Helper helper = new Helper('''
 typedef F();
 var t = F;
 ''');
-    helper.checkTypeReference('F', 'F', AccessKind.TOPLEVEL_TYPE);
+    helper.checkTypeReference('F', 'F', AccessKind.TOPLEVEL_TYPE, isRead: true);
   });
 
   test('Get function typedef defined at top level via prefix', () {
     Helper helper = new Helper('''
 import 'lib.dart' as l;
 
 var t = l.F;
 ''');
     helper.addFile('/lib.dart', '''
 library lib;
 
 typedef F();
 ''');
-    helper.checkTypeReference('l.F', 'F', AccessKind.TOPLEVEL_TYPE);
+    helper.checkTypeReference(
+        'l.F',
+        'F',
+        AccessKind.TOPLEVEL_TYPE,
+        isRead: true);
   });
 
   test('Get mixin application defined at top level', () {
     Helper helper = new Helper('''
 class A {}
 class B {}
 class C = A with B;
 var t = C;
 ''');
-    helper.checkTypeReference('C', 'C', AccessKind.TOPLEVEL_TYPE);
+    helper.checkTypeReference('C', 'C', AccessKind.TOPLEVEL_TYPE, isRead: true);
   });
 
   test('Get mixin application defined at top level via prefix', () {
     Helper helper = new Helper('''
 import 'lib.dart' as l;
 
 var t = l.C;
 ''');
     helper.addFile('/lib.dart', '''
 library lib;
 
 class A;
 class B;
 class C = A with B;
 ''');
-    helper.checkTypeReference('l.C', 'C', AccessKind.TOPLEVEL_TYPE);
+    helper.checkTypeReference(
+        'l.C',
+        'C',
+        AccessKind.TOPLEVEL_TYPE,
+        isRead: true);
   });
 
   test('Get type parameter of enclosing class', () {
     Helper helper = new Helper('''
 class A<T, U> {
   f() {
     var t = U;
   }
 }
 ''');
-    helper.checkTypeReference('U', 'U', AccessKind.TYPE_PARAMETER);
+    helper.checkTypeReference(
+        'U',
+        'U',
+        AccessKind.TYPE_PARAMETER,
+        isRead: true);
   });
 
   test('Set variable defined at top level', () {
     Helper helper = new Helper('''
 var x;
 
 f() {
   x = 1;
 }
 ''');
@@ skipping 33 matching lines @@
   static var x;
 
   f() {
     x = 1;
   }
 }
 ''');
     helper.checkStaticField('x', 'A', 'x', isWrite: true);
   });
 
-  test('Set field defined statically in class from inside class in foreach' +
-      ' loop', () {
+  test(
+      'Set field defined statically in class from inside class in foreach' + ' loop',
+      () {
     Helper helper = new Helper('''
 class A {
   static var x;
 
   f() {
     for (x in []) {}
   }
 }
 ''');
     helper.checkStaticField('x', 'A', 'x', isWrite: true);
@@ skipping 38 matching lines @@
   var x;
 
   f() {
     x = 1;
   }
 }
 ''');
     helper.checkDynamic('x', null, 'x', isWrite: true);
   });
 
-  test('Set field defined dynamically in class from inside class in foreach' +
-      ' loop', () {
+  test(
+      'Set field defined dynamically in class from inside class in foreach' + ' loop',
+      () {
     Helper helper = new Helper('''
 class A {
   var x;
 
   f() {
     for (x in []) {}
   }
 }
 ''');
     helper.checkDynamic('x', null, 'x', isWrite: true);
@@ skipping 113 matching lines @@
   static set x(value) {}
 
   f() {
     x = 1;
   }
 }
 ''');
     helper.checkStaticProperty('x', 'A', 'x', true, isWrite: true);
   });
 
-  test('Set accessor defined statically in class from inside class in' +
-      ' foreach loop', () {
+  test(
+      'Set accessor defined statically in class from inside class in' +
+          ' foreach loop',
+      () {
     Helper helper = new Helper('''
 class A {
   static set x(value) {}
 
   f() {
     for (x in []) {}
   }
 }
 ''');
     helper.checkStaticProperty('x', 'A', 'x', true, isWrite: true);
@@ skipping 38 matching lines @@
   set x(value) {}
 
   f() {
     x = 1;
   }
 }
 ''');
     helper.checkDynamic('x', null, 'x', isWrite: true);
   });
 
-  test('Set accessor defined dynamically in class from inside class in' +
-      ' foreach loop', () {
+  test(
+      'Set accessor defined dynamically in class from inside class in' +
+          ' foreach loop',
+      () {
     Helper helper = new Helper('''
 class A {
   set x(value) {}
 
   f() {
     for (x in []) {}
   }
 }
 ''');
     helper.checkDynamic('x', null, 'x', isWrite: true);
@@ skipping 120 matching lines @@
     Helper helper = new Helper('''
 class A {
   f() {
     x = 1;
   }
 }
 ''');
     helper.checkDynamic('x', null, 'x', isWrite: true);
   });
 
-  test('Set accessor undefined dynamically in class from inside class in' +
-      ' foreach loop', () {
+  test(
+      'Set accessor undefined dynamically in class from inside class in' +
+          ' foreach loop',
+      () {
     Helper helper = new Helper('''
 class A {
   f() {
     for (x in []) {}
   }
 }
 ''');
     helper.checkDynamic('x', null, 'x', isWrite: true);
   });
 
@@ skipping 431 matching lines @@
 A h() => null;
 
 f() {
   h().x += 1;
 }
 ''');
     helper.checkDynamic('h().x', 'h()', 'x', isRead: true, isWrite: true);
   });
 }
 
+typedef void AccessHandler(Expression node, AccessSemantics semantics);
+
 class Helper {
   final MemoryResourceProvider provider = new MemoryResourceProvider();
   Source rootSource;
   AnalysisContext context;
 
   Helper(String rootContents) {
     DartSdk sdk = new MockSdk();
     String rootFile = '/root.dart';
     File file = provider.newFile(rootFile, rootContents);
     rootSource = file.createSource();
     context = AnalysisEngine.instance.createAnalysisContext();
     // Set up the source factory.
     List<UriResolver> uriResolvers = [
         new ResourceUriResolver(provider),
         new DartUriResolver(sdk)];
     context.sourceFactory = new SourceFactory(uriResolvers);
     // add the Source
     ChangeSet changeSet = new ChangeSet();
     changeSet.addedSource(rootSource);
     context.applyChanges(changeSet);
   }
 
+  LibraryElement get libraryElement {
+    return context.computeLibraryElement(rootSource);
+  }
+
   void addFile(String path, String contents) {
     provider.newFile(path, contents);
   }
 
-  LibraryElement get libraryElement {
-    return context.computeLibraryElement(rootSource);
-  }
-
   /**
    * Verify that the node represented by [expectedSource] is classified as
-   * a static field element reference.
+   * a dynamic method invocation.
    */
-  void checkStaticField(String expectedSource, String expectedClass,
+  void checkDynamic(String expectedSource, String expectedTarget,
       String expectedName, {bool isRead: false, bool isWrite: false, bool isInvoke:
       false}) {
     TestVisitor visitor = new TestVisitor();
     int count = 0;
-    visitor.onAccess = (Expression node, AccessSemantics semantics) {
+    visitor.onAccess = (AstNode node, AccessSemantics semantics) {
       count++;
       expect(node.toSource(), equals(expectedSource));
-      expect(semantics.kind, equals(AccessKind.STATIC_FIELD));
+      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.element.displayName, equals(expectedName));
-      if (expectedClass == null) {
-        expect(semantics.classElement, isNull);
-      } else {
-        expect(semantics.classElement, isNotNull);
-        expect(semantics.classElement.displayName, equals(expectedClass));
-      }
-      expect(semantics.target, isNull);
+      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 static property access.
+   * a local function invocation.
    */
-  void checkStaticProperty(String expectedSource, String expectedClass,
-      String expectedName, bool defined, {bool isRead: false, bool isWrite: false,
-      bool isInvoke: false}) {
+  void checkLocalFunction(String expectedSource, String expectedName,
+      {bool isRead: false, bool isWrite: false, bool isInvoke: false}) {
     TestVisitor visitor = new TestVisitor();
     int count = 0;
-    visitor.onAccess = (Expression node, AccessSemantics semantics) {
+    visitor.onAccess = (AstNode node, AccessSemantics semantics) {
       count++;
       expect(node.toSource(), equals(expectedSource));
-      expect(semantics.kind, equals(AccessKind.STATIC_PROPERTY));
+      expect(semantics.kind, equals(AccessKind.LOCAL_FUNCTION));
       expect(semantics.identifier.name, equals(expectedName));
-      if (expectedClass == null) {
-        expect(semantics.classElement, isNull);
-      } else {
-        expect(semantics.classElement, isNotNull);
-        expect(semantics.classElement.displayName, equals(expectedClass));
-      }
-      if (defined) {
-        expect(semantics.element.displayName, equals(expectedName));
-      } else {
-        expect(semantics.element, isNull);
-      }
+      expect(semantics.element.displayName, 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));
   }
 
   /**
    * Verify that the node represented by [expectedSource] is classified as
-   * a static method.
+   * a local variable access.
    */
-  void checkStaticMethod(String expectedSource, String expectedClass,
-      String expectedName, bool defined, {bool isRead: false, bool isWrite: false,
-      bool isInvoke: false}) {
+  void checkLocalVariable(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.STATIC_METHOD));
-      expect(semantics.identifier.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));
-        if (defined) {
-          expect(semantics.element, new isInstanceOf<MethodElement>());
-        }
-      }
-      if (defined) {
-        expect(semantics.element.displayName, equals(expectedName));
-      } else {
-        expect(semantics.element, isNull);
-      }
+      expect(semantics.kind, equals(AccessKind.LOCAL_VARIABLE));
+      expect(semantics.element.name, 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));
   }
 
   /**
-   * Verify that the node represented by [expectedSource] is classified as
-   * a dynamic method invocation.
+   * Verify that the node represented by [expectedSource] is classified as a
+   * parameter access.
    */
-  void checkDynamic(String expectedSource, String expectedTarget,
-      String expectedName, {bool isRead: false, bool isWrite: false, bool isInvoke:
-      false}) {
+  void checkParameter(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.DYNAMIC));
-      if (expectedTarget == null) {
-        expect(semantics.target, isNull);
-      } else {
-        expect(semantics.target.toSource(), equals(expectedTarget));
-      }
-      expect(semantics.identifier.name, equals(expectedName));
-      expect(semantics.element, isNull);
+      expect(semantics.kind, equals(AccessKind.PARAMETER));
+      expect(semantics.element.name, 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));
   }
 
   /**
    * Verify that the node represented by [expectedSource] is classified as
-   * a local function invocation.
+   * a static field element reference.
    */
-  void checkLocalFunction(String expectedSource, String expectedName,
-      {bool isRead: false, bool isWrite: false, bool isInvoke: false}) {
+  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 = (AstNode node, AccessSemantics semantics) {
+    visitor.onAccess = (Expression node, AccessSemantics semantics) {
       count++;
       expect(node.toSource(), equals(expectedSource));
-      expect(semantics.kind, equals(AccessKind.LOCAL_FUNCTION));
+      expect(semantics.kind, equals(AccessKind.STATIC_FIELD));
       expect(semantics.identifier.name, equals(expectedName));
       expect(semantics.element.displayName, equals(expectedName));
-      expect(semantics.classElement, isNull);
+      if (expectedClass == null) {
+        expect(semantics.classElement, isNull);
+      } else {
+        expect(semantics.classElement, isNotNull);
+        expect(semantics.classElement.displayName, 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 local variable access.
+   * a static method.
    */
-  void checkLocalVariable(String expectedSource, String expectedName,
-      {bool isRead: false, bool isWrite: false, bool isInvoke: false}) {
+  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.LOCAL_VARIABLE));
-      expect(semantics.element.name, equals(expectedName));
-      expect(semantics.classElement, isNull);
+      expect(semantics.kind, equals(AccessKind.STATIC_METHOD));
+      expect(semantics.identifier.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));
+        if (defined) {
+          expect(semantics.element, new isInstanceOf<MethodElement>());
+        }
+      }
+      if (defined) {
+        expect(semantics.element.displayName, 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
-   * parameter access.
+   * Verify that the node represented by [expectedSource] is classified as
+   * a static property access.
    */
-  void checkParameter(String expectedSource, String expectedName, {bool isRead:
-      false, bool isWrite: false, bool isInvoke: false}) {
+  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 = (AstNode node, AccessSemantics semantics) {
+    visitor.onAccess = (Expression node, AccessSemantics semantics) {
       count++;
       expect(node.toSource(), equals(expectedSource));
-      expect(semantics.kind, equals(AccessKind.PARAMETER));
-      expect(semantics.element.name, equals(expectedName));
-      expect(semantics.classElement, isNull);
+      expect(semantics.kind, equals(AccessKind.STATIC_PROPERTY));
+      expect(semantics.identifier.name, equals(expectedName));
+      if (expectedClass == null) {
+        expect(semantics.classElement, isNull);
+      } else {
+        expect(semantics.classElement, isNotNull);
+        expect(semantics.classElement.displayName, equals(expectedClass));
+      }
+      if (defined) {
+        expect(semantics.element.displayName, 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
    * reference to a toplevel class or a type parameter.
    */
-  void checkTypeReference(
-      String expectedSource, String expectedName, AccessKind expectedKind) {
+  void checkTypeReference(String expectedSource, String expectedName,
+      AccessKind expectedKind, {bool isRead: 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(expectedKind));
       expect(semantics.element.name, equals(expectedName));
       expect(semantics.classElement, isNull);
       expect(semantics.target, isNull);
-      expect(semantics.isRead, isTrue);
+      expect(semantics.isRead, equals(isRead));
       expect(semantics.isWrite, isFalse);
-      expect(semantics.isInvoke, isFalse);
+      expect(semantics.isInvoke, equals(isInvoke));
     };
     libraryElement.unit.accept(visitor);
     expect(count, equals(1));
   }
 }
 
-typedef void AccessHandler(Expression node, AccessSemantics semantics);
-
 /**
  * Visitor class used to run the tests.
  */
 class TestVisitor extends RecursiveAstVisitor {
   AccessHandler onAccess;
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     onAccess(node, node.accept(ACCESS_SEMANTICS_VISITOR));
   }
 
   @override
   visitPrefixedIdentifier(PrefixedIdentifier node) {
     onAccess(node, node.accept(ACCESS_SEMANTICS_VISITOR));
   }
 
   @override
   visitPropertyAccess(PropertyAccess node) {
     onAccess(node, node.accept(ACCESS_SEMANTICS_VISITOR));
   }
 
   @override
   visitSimpleIdentifier(SimpleIdentifier node) {
     AccessSemantics semantics = node.accept(ACCESS_SEMANTICS_VISITOR);
     if (semantics != null) {
       onAccess(node, semantics);
     }
   }
 }