diff --git a/pkg/analyzer/lib/src/dart/analysis/dependency/library_builder.dart b/pkg/analyzer/lib/src/dart/analysis/dependency/library_builder.dart
index 26cb1fa..308b816 100644
--- a/pkg/analyzer/lib/src/dart/analysis/dependency/library_builder.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/dependency/library_builder.dart
@@ -274,7 +274,8 @@
       var builder = _newApiSignatureBuilder();
       builder.addString(node.name.name);
       _appendTokens(builder, node.leftBracket, node.rightBracket);
-      fieldDependencies = Dependencies(builder.toByteList(), [], [], [], []);
+      var tokenSignature = builder.toByteList();
+      fieldDependencies = Dependencies(tokenSignature, [], [], [], [], []);
     }
 
     var members = <Node>[];
@@ -305,7 +306,7 @@
     var enumNode = Node(
       LibraryQualifiedName(uri, node.name.name),
       NodeKind.ENUM,
-      Dependencies(enumTokenSignature, [], [], [], []),
+      Dependencies(enumTokenSignature, [], [], [], [], []),
       Dependencies.none,
     );
     enumNode.setClassMembers(members);
@@ -640,6 +641,7 @@
       importPrefixes,
       importPrefixedReferencedNames,
       const [],
+      const [],
     );
   }
 
diff --git a/pkg/analyzer/lib/src/dart/analysis/dependency/node.dart b/pkg/analyzer/lib/src/dart/analysis/dependency/node.dart
index 71791d6..6fe7d43 100644
--- a/pkg/analyzer/lib/src/dart/analysis/dependency/node.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/dependency/node.dart
@@ -16,46 +16,38 @@
   /// will notice added overrides in the target class, or anywhere in between.
   final LibraryQualifiedName target;
 
-  /// Whether the explicit `super` was used as the target.
-  /// The [target] is the enclosing class.
-  final bool targetSuper;
-
   /// The name referenced in the [target].
   final String name;
 
   @override
   final int hashCode;
 
-  ClassMemberReference(this.target, this.targetSuper, this.name)
+  ClassMemberReference(this.target, this.name)
       : hashCode = JenkinsSmiHash.hash2(target.hashCode, name.hashCode);
 
   @override
   bool operator ==(other) {
     return other is ClassMemberReference &&
         other.target == target &&
-        other.targetSuper == targetSuper &&
         other.name == name;
   }
 
   @override
   String toString() {
-    return '($target, $name, super: $targetSuper)';
+    return '($target, $name)';
   }
 
   static int compare(ClassMemberReference first, ClassMemberReference second) {
     var result = LibraryQualifiedName.compare(first.target, second.target);
     if (result != 0) return result;
 
-    if (first.targetSuper && !second.targetSuper) return -1;
-    if (!first.targetSuper && second.targetSuper) return 1;
-
     return first.name.compareTo(second.name);
   }
 }
 
 /// The dependencies of the API or implementation portion of a node.
 class Dependencies {
-  static final none = Dependencies([], [], [], [], []);
+  static final none = Dependencies([], [], [], [], [], []);
 
   /// The token signature of this portion of the node. It depends on all
   /// tokens that might affect the node API or implementation resolution.
@@ -79,6 +71,11 @@
   /// This list is sorted.
   final List<List<String>> importPrefixedReferencedNames;
 
+  /// The names that appear prefixed with `super` in this portion of the node.
+  ///
+  /// This list is sorted.
+  final List<String> superReferencedNames;
+
   /// The class members referenced in this portion of the node.
   ///
   /// This list is sorted.
@@ -98,6 +95,7 @@
       this.unprefixedReferencedNames,
       this.importPrefixes,
       this.importPrefixedReferencedNames,
+      this.superReferencedNames,
       this.classMemberReferences);
 
   String get tokenSignatureHex => hex.encode(tokenSignature);
diff --git a/pkg/analyzer/lib/src/dart/analysis/dependency/reference_collector.dart b/pkg/analyzer/lib/src/dart/analysis/dependency/reference_collector.dart
index 2ad3cb6..7bd603d 100644
--- a/pkg/analyzer/lib/src/dart/analysis/dependency/reference_collector.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/dependency/reference_collector.dart
@@ -3,9 +3,11 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/analysis/dependency/node.dart';
+import 'package:analyzer/src/dart/ast/token.dart';
 
 /// Collector of information about external nodes referenced by a node.
 ///
@@ -28,6 +30,9 @@
   /// It is filled by [addImportPrefix] and shared across all nodes.
   List<_ReferencedImportPrefixedNames> _importPrefixedReferences = [];
 
+  /// The list of names that are referenced with `super`.
+  _NameSet _superReferences = _NameSet();
+
   /// The set of referenced class members.
   _ClassMemberReferenceSet _memberReferences = new _ClassMemberReferenceSet();
 
@@ -59,7 +64,7 @@
       _visitExpression(expression);
     }
     if (formalParameters != null) {
-      _visitFormalParameters(formalParameters);
+      _visitFormalParameterList(formalParameters);
     }
     if (functionBody != null) {
       _visitFunctionBody(functionBody);
@@ -85,6 +90,9 @@
       import.clear();
     }
 
+    var superReferencedNames = _superReferences.toList();
+    _superReferences = _NameSet();
+
     var classMemberReferences = _memberReferences.toList();
     _memberReferences = _ClassMemberReferenceSet();
 
@@ -93,6 +101,7 @@
       unprefixedReferencedNames,
       importPrefixes,
       importPrefixedReferencedNames,
+      superReferencedNames,
       classMemberReferences,
     );
   }
@@ -109,10 +118,9 @@
     return null;
   }
 
-  void _recordClassMemberReference(
-      DartType targetType, bool withSuper, String name) {
+  void _recordClassMemberReference(DartType targetType, String name) {
     if (targetType is InterfaceType) {
-      _memberReferences.add(targetType, withSuper, name);
+      _memberReferences.add(targetType, name);
     }
   }
 
@@ -122,53 +130,121 @@
     _unprefixedReferences.add(name);
   }
 
+  void _visitAdjacentStrings(AdjacentStrings node) {
+    var strings = node.strings;
+    for (var i = 0; i < strings.length; i++) {
+      var string = strings[i];
+      _visitExpression(string);
+    }
+  }
+
+  void _visitArgumentList(ArgumentList argumentList) {
+    var arguments = argumentList.arguments;
+    for (var i = 0; i < arguments.length; i++) {
+      var argument = arguments[i];
+      _visitExpression(argument);
+    }
+  }
+
+  void _visitCascadeExpression(CascadeExpression node) {
+    _visitExpression(node.target);
+    var sections = node.cascadeSections;
+    for (var i = 0; i < sections.length; i++) {
+      var section = sections[i];
+      _visitExpression(section);
+    }
+  }
+
   void _visitExpression(Expression node) {
     if (node == null) return;
 
-    if (node is AssignmentExpression) {
+    if (node is AdjacentStrings) {
+      _visitAdjacentStrings(node);
+    } else if (node is AsExpression) {
+      _visitExpression(node.expression);
+      _visitTypeAnnotation(node.type);
+    } else if (node is AssignmentExpression) {
       _visitExpression(node.leftHandSide);
       _visitExpression(node.rightHandSide);
-      // TODO(scheglov) operator
+      var assignmentType = node.operator.type;
+      if (assignmentType != TokenType.EQ &&
+          assignmentType != TokenType.QUESTION_QUESTION_EQ) {
+        var operatorType = operatorFromCompoundAssignment(assignmentType);
+        _recordClassMemberReference(
+          node.leftHandSide.staticType,
+          operatorType.lexeme,
+        );
+      }
+    } else if (node is AwaitExpression) {
+      _visitExpression(node.expression);
     } else if (node is BinaryExpression) {
       _visitExpression(node.leftOperand);
       _visitExpression(node.rightOperand);
       _recordClassMemberReference(
         node.leftOperand.staticType,
-        false,
         node.operator.lexeme,
       );
     } else if (node is BooleanLiteral) {
       // no dependencies
+    } else if (node is CascadeExpression) {
+      _visitCascadeExpression(node);
     } else if (node is ConditionalExpression) {
-      // TODO(scheglov) test
       _visitExpression(node.condition);
       _visitExpression(node.thenExpression);
       _visitExpression(node.elseExpression);
     } else if (node is DoubleLiteral) {
       // no dependencies
+    } else if (node is FunctionExpression) {
+      _visitFunctionExpression(node);
+    } else if (node is FunctionExpressionInvocation) {
+      _visitExpression(node.function);
+      _visitTypeArguments(node.typeArguments);
+      _visitArgumentList(node.argumentList);
     } else if (node is IndexExpression) {
       _visitExpression(node.target);
       _visitExpression(node.index);
+    } else if (node is InstanceCreationExpression) {
+      _visitInstanceCreationExpression(node);
     } else if (node is IntegerLiteral) {
       // no dependencies
+    } else if (node is IsExpression) {
+      _visitExpression(node.expression);
+      _visitTypeAnnotation(node.type);
     } else if (node is ListLiteral) {
       _visitListLiteral(node);
     } else if (node is MapLiteral) {
       _visitMapLiteral(node);
     } else if (node is MethodInvocation) {
       _visitMethodInvocation(node);
+    } else if (node is NamedExpression) {
+      _visitExpression(node.expression);
+    } else if (node is NullLiteral) {
+      // no dependencies
     } else if (node is ParenthesizedExpression) {
       _visitExpression(node.expression);
+    } else if (node is PostfixExpression) {
+      _visitPostfixExpression(node);
     } else if (node is PrefixExpression) {
       _visitPrefixExpression(node);
     } else if (node is PrefixedIdentifier) {
       _visitPrefixedIdentifier(node);
+    } else if (node is PropertyAccess) {
+      _visitPropertyAccess(node);
     } else if (node is SetLiteral) {
       _visitSetLiteral(node);
     } else if (node is SimpleIdentifier) {
       _visitSimpleIdentifier(node);
+    } else if (node is SimpleStringLiteral) {
+      // no dependencies
+    } else if (node is StringInterpolation) {
+      _visitStringInterpolation(node);
+    } else if (node is ThisExpression) {
+      // no dependencies
+      // TODO(scheglov) not really, because "this" type depends on the hierarchy
+    } else if (node is ThrowExpression) {
+      _visitExpression(node.expression);
     } else {
-//      throw UnimplementedError('(${node.runtimeType}) $node');
+      throw UnimplementedError('(${node.runtimeType}) $node');
     }
   }
 
@@ -195,7 +271,7 @@
     _localScopes.exit();
   }
 
-  void _visitFormalParameters(FormalParameterList node) {
+  void _visitFormalParameterList(FormalParameterList node) {
     if (node == null) return;
 
     var parameters = node.parameters;
@@ -211,7 +287,7 @@
       }
       if (parameter is FunctionTypedFormalParameter) {
         _visitTypeAnnotation(parameter.returnType);
-        _visitFormalParameters(parameter.parameters);
+        _visitFormalParameterList(parameter.parameters);
       } else if (parameter is SimpleFormalParameter) {
         _visitTypeAnnotation(parameter.type);
       } else {
@@ -255,14 +331,33 @@
   void _visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
     var function = node.functionDeclaration;
     _visitTypeAnnotation(function.returnType);
+    _visitFunctionExpression(function.functionExpression);
+  }
 
+  void _visitFunctionExpression(FunctionExpression node) {
     _localScopes.enter();
-    var functionExpression = function.functionExpression;
-    _visitFormalParameters(functionExpression.parameters);
-    _visitFunctionBody(functionExpression.body);
+    _visitTypeParameterList(node.typeParameters);
+    _visitFormalParameterList(node.parameters);
+    _visitFunctionBody(node.body);
     _localScopes.exit();
   }
 
+  void _visitInstanceCreationExpression(InstanceCreationExpression node) {
+    var constructor = node.constructorName;
+
+    _visitTypeAnnotation(constructor.type);
+
+    var instantiatedType = constructor.type.type;
+    var name = constructor.name;
+    if (name != null) {
+      _recordClassMemberReference(instantiatedType, name.name);
+    } else {
+      _recordClassMemberReference(instantiatedType, '');
+    }
+
+    _visitArgumentList(node.argumentList);
+  }
+
   void _visitListLiteral(ListLiteral node) {
     _visitTypeArguments(node.typeArguments);
     var elements = node.elements;
@@ -283,25 +378,32 @@
   }
 
   void _visitMethodInvocation(MethodInvocation node) {
-    _visitExpression(node.target);
     var realTarget = node.realTarget;
     if (realTarget == null) {
       _visitExpression(node.methodName);
     } else if (realTarget is SuperExpression) {
-      // TODO(scheglov) implement
-      //        throw UnimplementedError('$node');
+      _superReferences.add(node.methodName.name);
     } else {
+      _visitExpression(node.target);
       _recordClassMemberReference(
         realTarget.staticType,
-        false,
         node.methodName.name,
       );
     }
-    // TODO(scheglov) tests
-    var arguments = node.argumentList.arguments;
-    for (var i = 0; i < arguments.length; i++) {
-      var argument = arguments[i];
-      _visitExpression(argument);
+    _visitTypeArguments(node.typeArguments);
+    _visitArgumentList(node.argumentList);
+  }
+
+  void _visitPostfixExpression(PostfixExpression node) {
+    _visitExpression(node.operand);
+
+    var operator = node.operator.type;
+    if (operator == TokenType.MINUS_MINUS) {
+      _recordClassMemberReference(node.operand.staticType, '-');
+    } else if (operator == TokenType.PLUS_PLUS) {
+      _recordClassMemberReference(node.operand.staticType, '+');
+    } else {
+      throw UnimplementedError('$operator');
     }
   }
 
@@ -310,18 +412,11 @@
     var prefixElement = prefix.staticElement;
     if (prefixElement is PrefixElement) {
       var prefixName = prefix.name;
-      // TODO(scheglov) remove this null check work around
       var importPrefix = _importPrefix(prefixName);
-      if (importPrefix != null) {
-        importPrefix.add(node.identifier.name);
-      }
+      importPrefix.add(node.identifier.name);
     } else {
       _visitExpression(prefix);
-      _recordClassMemberReference(
-        prefix.staticType,
-        false,
-        node.identifier.name,
-      );
+      _recordClassMemberReference(prefix.staticType, node.identifier.name);
     }
   }
 
@@ -331,11 +426,20 @@
     var operatorName = node.operator.lexeme;
     if (operatorName == '-') operatorName = 'unary-';
 
-    _recordClassMemberReference(
-      node.operand.staticType,
-      false,
-      operatorName,
-    );
+    _recordClassMemberReference(node.operand.staticType, operatorName);
+  }
+
+  void _visitPropertyAccess(PropertyAccess node) {
+    var realTarget = node.realTarget;
+    if (realTarget is SuperExpression) {
+      _superReferences.add(node.propertyName.name);
+    } else {
+      _visitExpression(node.target);
+      _recordClassMemberReference(
+        realTarget.staticType,
+        node.propertyName.name,
+      );
+    }
   }
 
   void _visitSetLiteral(SetLiteral node) {
@@ -352,6 +456,7 @@
 
     var name = node.name;
     if (!_localScopes.contains(name) && name != 'void' && name != 'dynamic') {
+      // TODO(scheglov) use `name=` if assignment context, or both
       _recordUnprefixedReference(name);
     }
   }
@@ -428,6 +533,16 @@
     _localScopes.exit();
   }
 
+  void _visitStringInterpolation(StringInterpolation node) {
+    var elements = node.elements;
+    for (var i = 0; i < elements.length; i++) {
+      var element = elements[i];
+      if (element is InterpolationExpression) {
+        _visitExpression(element.expression);
+      }
+    }
+  }
+
   void _visitSwitchStatement(SwitchStatement node) {
     _visitExpression(node.expression);
     var members = node.members;
@@ -465,7 +580,7 @@
       }
 
       _visitTypeAnnotation(node.returnType);
-      _visitFormalParameters(node.parameters);
+      _visitFormalParameterList(node.parameters);
 
       _localScopes.exit();
     } else if (node is TypeName) {
@@ -487,6 +602,17 @@
     }
   }
 
+  void _visitTypeParameterList(TypeParameterList node) {
+    if (node == null) return;
+
+    var typeParameters = node.typeParameters;
+    for (var i = 0; i < typeParameters.length; i++) {
+      var typeParameter = typeParameters[i];
+      _localScopes.add(typeParameter.name.name);
+      _visitTypeAnnotation(typeParameter.bound);
+    }
+  }
+
   void _visitVariableList(VariableDeclarationList node) {
     if (node == null) return;
 
@@ -505,10 +631,10 @@
 class _ClassMemberReferenceSet {
   final List<ClassMemberReference> references = [];
 
-  void add(InterfaceType type, bool withSuper, String name) {
+  void add(InterfaceType type, String name) {
     var class_ = type.element;
     var target = LibraryQualifiedName(class_.library.source.uri, class_.name);
-    var reference = ClassMemberReference(target, withSuper, name);
+    var reference = ClassMemberReference(target, name);
     if (!references.contains(reference)) {
       references.add(reference);
     }
diff --git a/pkg/analyzer/test/src/dart/analysis/dependency/reference_collector_test.dart b/pkg/analyzer/test/src/dart/analysis/dependency/reference_collector_test.dart
index cd73479..587a193 100644
--- a/pkg/analyzer/test/src/dart/analysis/dependency/reference_collector_test.dart
+++ b/pkg/analyzer/test/src/dart/analysis/dependency/reference_collector_test.dart
@@ -22,6 +22,70 @@
 
 @reflectiveTest
 class ExpressionReferenceCollectorTest extends _Base {
+  test_adjacentStrings() async {
+    var library = await buildTestLibrary(a, r'''
+test() {
+  'foo' '$x' 'bar';
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION, unprefixed: ['x']);
+  }
+
+  test_asExpression() async {
+    var library = await buildTestLibrary(a, r'''
+test() {
+  x as Y;
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION, unprefixed: ['Y', 'x']);
+  }
+
+  test_assignmentExpression() async {
+    var library = await buildTestLibrary(a, r'''
+test() {
+  x = y;
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION, unprefixed: ['x', 'y']);
+  }
+
+  test_assignmentExpression_compound() async {
+    var library = await buildTestLibrary(a, r'''
+class A {
+  operator+(_) {}
+}
+
+class B extends A {}
+
+B x, y;
+
+test() {
+  x += y;
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION,
+        unprefixed: ['x', 'y'],
+        expectedMembers: [_ExpectedClassMember(aUri, 'B', '+')]);
+  }
+
+  test_assignmentExpression_nullAware() async {
+    var library = await buildTestLibrary(a, r'''
+test() {
+  x ??= y;
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION, unprefixed: ['x', 'y']);
+  }
+
+  test_awaitExpression() async {
+    var library = await buildTestLibrary(a, r'''
+test() async {
+  await x;
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION, unprefixed: ['x']);
+  }
+
   test_binaryExpression() async {
     var library = await buildTestLibrary(a, r'''
 class A {
@@ -140,6 +204,39 @@
     _assertImpl(library, 'test', NodeKind.FUNCTION);
   }
 
+  test_cascadeExpression() async {
+    var library = await buildTestLibrary(a, r'''
+class A {}
+
+A x;
+
+test() {
+  x
+    ..foo(y)
+    ..bar = z;
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION, unprefixed: [
+      'x',
+      'y',
+      'z'
+    ], expectedMembers: [
+      _ExpectedClassMember(aUri, 'A', 'bar'),
+      _ExpectedClassMember(aUri, 'A', 'foo'),
+    ]);
+    // TODO(scheglov) should be `bar=`
+  }
+
+  test_conditionalExpression() async {
+    var library = await buildTestLibrary(a, r'''
+test() {
+  x ? y : z;
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION,
+        unprefixed: ['x', 'y', 'z']);
+  }
+
   test_doubleLiteral() async {
     var library = await buildTestLibrary(a, r'''
 test() {
@@ -149,6 +246,111 @@
     _assertImpl(library, 'test', NodeKind.FUNCTION);
   }
 
+  test_functionExpression() async {
+    var library = await buildTestLibrary(a, r'''
+test() {
+  <T extends A, U extends T>(B b, C c, T t, U u) {
+    T;
+    U;
+    x;
+  }
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION,
+        unprefixed: ['A', 'B', 'C', 'x']);
+  }
+
+  test_functionExpressionInvocation() async {
+    var library = await buildTestLibrary(a, r'''
+test() {
+  (x)<T>(y, z);
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION,
+        unprefixed: ['T', 'x', 'y', 'z']);
+  }
+
+  test_indexExpression() async {
+    var library = await buildTestLibrary(a, r'''
+test() {
+  x[y];
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION, unprefixed: ['x', 'y']);
+  }
+
+  test_instanceCreationExpression_explicitNew_named() async {
+    var library = await buildTestLibrary(a, r'''
+class A {}
+
+test() {
+  new A<T>.named(x, b: y);
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION,
+        unprefixed: ['A', 'T', 'x', 'y'],
+        expectedMembers: [_ExpectedClassMember(aUri, 'A', 'named')]);
+  }
+
+  test_instanceCreationExpression_explicitNew_unnamed() async {
+    var library = await buildTestLibrary(a, r'''
+class A {}
+
+test() {
+  new A<T>(x, b: y);
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION,
+        unprefixed: ['A', 'T', 'x', 'y'],
+        expectedMembers: [_ExpectedClassMember(aUri, 'A', '')]);
+  }
+
+  test_instanceCreationExpression_explicitNew_unresolvedClass() async {
+    var library = await buildTestLibrary(a, r'''
+test() {
+  new A<T>.named(x);
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION,
+        unprefixed: ['A', 'T', 'x']);
+  }
+
+  test_instanceCreationExpression_implicitNew_named() async {
+    var library = await buildTestLibrary(a, r'''
+class A {}
+
+test() {
+  A<T>.named(x, b: y);
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION,
+        unprefixed: ['A', 'T', 'x', 'y'],
+        expectedMembers: [_ExpectedClassMember(aUri, 'A', 'named')]);
+  }
+
+  test_instanceCreationExpression_implicitNew_unnamed() async {
+    var library = await buildTestLibrary(a, r'''
+class A {}
+
+test() {
+  A<T>(x, b: y);
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION,
+        unprefixed: ['A', 'T', 'x', 'y'],
+        expectedMembers: [_ExpectedClassMember(aUri, 'A', '')]);
+  }
+
+  test_instanceCreationExpression_implicitNew_unresolvedClass_named() async {
+    var library = await buildTestLibrary(a, r'''
+test() {
+  A<T>.named(x, b: y);
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION,
+        unprefixed: ['A', 'T', 'x', 'y']);
+  }
+
   test_integerLiteral() async {
     var library = await buildTestLibrary(a, r'''
 test() {
@@ -158,6 +360,15 @@
     _assertImpl(library, 'test', NodeKind.FUNCTION);
   }
 
+  test_isExpression() async {
+    var library = await buildTestLibrary(a, r'''
+test() {
+  x is Y;
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION, unprefixed: ['Y', 'x']);
+  }
+
   test_listLiteral() async {
     var library = await buildTestLibrary(a, r'''
 test() {
@@ -178,23 +389,83 @@
         unprefixed: ['A', 'B', 'v', 'w', 'x', 'y']);
   }
 
-  test_methodInvocation() async {
+  test_methodInvocation_instance_withoutTarget_function() async {
     var library = await buildTestLibrary(a, r'''
-class A {
-  void foo() {}
-}
-
-class B extends A {}
-
-B x;
+void foo(a, {b}) {}
 
 test() {
-  x.foo();
+  foo(x, b: y);
 }
 ''');
     _assertImpl(library, 'test', NodeKind.FUNCTION,
-        unprefixed: ['x'],
-        expectedMembers: [_ExpectedClassMember(aUri, 'B', 'foo')]);
+        unprefixed: ['foo', 'x', 'y']);
+  }
+
+  test_methodInvocation_instance_withoutTarget_method() async {
+    var library = await buildTestLibrary(a, r'''
+class C {
+  void foo(a, {b}) {}
+
+  test() {
+    foo(x, b: y);
+  }
+}
+''');
+    _assertImpl(library, 'test', NodeKind.METHOD,
+        memberOf: 'C', unprefixed: ['foo', 'x', 'y']);
+  }
+
+  test_methodInvocation_instance_withTarget() async {
+    var library = await buildTestLibrary(a, r'''
+class A {}
+
+A x;
+
+test() {
+  x.foo<T>(y, b: z);
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION,
+        unprefixed: ['T', 'x', 'y', 'z'],
+        expectedMembers: [_ExpectedClassMember(aUri, 'A', 'foo')]);
+  }
+
+  test_methodInvocation_instance_withTarget_super() async {
+    var library = await buildTestLibrary(a, r'''
+class A {
+  void foo(a, b) {}
+}
+
+class B extends A {
+  test() {
+    super.foo(x, y);
+  }
+}
+''');
+    _assertImpl(library, 'test', NodeKind.METHOD,
+        memberOf: 'B', unprefixed: ['x', 'y'], superPrefixed: ['foo']);
+  }
+
+  test_methodInvocation_static_withTarget() async {
+    var library = await buildTestLibrary(a, r'''
+class A {}
+
+test() {
+  A.foo<T>(x);
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION,
+        unprefixed: ['A', 'T', 'x'],
+        expectedMembers: [_ExpectedClassMember(aUri, 'A', 'foo')]);
+  }
+
+  test_nullLiteral() async {
+    var library = await buildTestLibrary(a, r'''
+test() {
+  null;
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION);
   }
 
   test_parenthesizedExpression() async {
@@ -206,6 +477,37 @@
     _assertImpl(library, 'test', NodeKind.FUNCTION, unprefixed: ['x']);
   }
 
+  test_postfixExpression() async {
+    var library = await buildTestLibrary(a, r'''
+class A {}
+class B extend A {}
+
+B x, y;
+
+test() {
+  x++;
+  y--;
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION, unprefixed: [
+      'x',
+      'y'
+    ], expectedMembers: [
+      _ExpectedClassMember(aUri, 'B', '+'),
+      _ExpectedClassMember(aUri, 'B', '-')
+    ]);
+  }
+
+  test_postfixExpression_unresolvedTarget() async {
+    var library = await buildTestLibrary(a, r'''
+test() {
+  x++;
+  y--;
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION, unprefixed: ['x', 'y']);
+  }
+
   test_prefixedIdentifier_importPrefix() async {
     newFile(b, content: 'var b = 0;');
     var library = await buildTestLibrary(a, r'''
@@ -252,6 +554,21 @@
         expectedMembers: [_ExpectedClassMember(aUri, 'B', 'y')]);
   }
 
+  test_prefixedIdentifier_static() async {
+    var library = await buildTestLibrary(a, r'''
+class A {}
+
+class B extends A {}
+
+test() {
+  B.x;
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION,
+        unprefixed: ['B'],
+        expectedMembers: [_ExpectedClassMember(aUri, 'B', 'x')]);
+  }
+
   test_prefixedIdentifier_unresolvedPrefix() async {
     var library = await buildTestLibrary(a, r'''
 test() {
@@ -304,6 +621,35 @@
     _assertImpl(library, 'test', NodeKind.FUNCTION, unprefixed: ['x']);
   }
 
+  test_propertyAccess() async {
+    var library = await buildTestLibrary(a, r'''
+class A {}
+
+class B extends A {}
+
+B x;
+
+test() {
+  (x).foo;
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION,
+        unprefixed: ['x'],
+        expectedMembers: [_ExpectedClassMember(aUri, 'B', 'foo')]);
+  }
+
+  test_propertyAccess_super() async {
+    var library = await buildTestLibrary(a, r'''
+class C {
+  test() {
+    super.foo;
+  }
+}
+''');
+    _assertImpl(library, 'test', NodeKind.METHOD,
+        memberOf: 'C', superPrefixed: ['foo']);
+  }
+
   test_setLiteral() async {
     var library = await buildTestLibrary(a, r'''
 test() {
@@ -350,6 +696,46 @@
 ''');
     _assertImpl(library, 'test', NodeKind.FUNCTION, unprefixed: ['x', 'y']);
   }
+
+  test_simpleStringLiteral() async {
+    var library = await buildTestLibrary(a, r'''
+test() {
+  '';
+  """""";
+  r"""""";
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION);
+  }
+
+  test_stringInterpolation() async {
+    var library = await buildTestLibrary(a, r'''
+test() {
+  '$x ${y}';
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION, unprefixed: ['x', 'y']);
+  }
+
+  test_thisExpression() async {
+    var library = await buildTestLibrary(a, r'''
+class C {
+  test() {
+    this;
+  }
+}
+''');
+    _assertImpl(library, 'test', NodeKind.METHOD, memberOf: 'C');
+  }
+
+  test_throwExpression() async {
+    var library = await buildTestLibrary(a, r'''
+test() {
+  throw x;
+}
+''');
+    _assertImpl(library, 'test', NodeKind.FUNCTION, unprefixed: ['x']);
+  }
 }
 
 @reflectiveTest
@@ -766,12 +1152,14 @@
   void _assertApi(Library library, String name, NodeKind kind,
       {List<String> unprefixed: const [],
       Map<String, List<String>> prefixed: const {},
+      List<String> superPrefixed: const [],
       List<_ExpectedClassMember> expectedMembers: const []}) {
     var node = getNode(library, name: name, kind: kind);
     _assertDependencies(
       node.api,
       unprefixed: unprefixed,
       prefixed: prefixed,
+      superPrefixed: superPrefixed,
       expectedMembers: expectedMembers,
     );
   }
@@ -779,10 +1167,12 @@
   void _assertDependencies(Dependencies dependencies,
       {List<String> unprefixed: const [],
       Map<String, List<String>> prefixed: const {},
+      List<String> superPrefixed: const [],
       List<_ExpectedClassMember> expectedMembers: const []}) {
     expect(dependencies.unprefixedReferencedNames, unprefixed);
     expect(dependencies.importPrefixes, prefixed.keys);
     expect(dependencies.importPrefixedReferencedNames, prefixed.values);
+    expect(dependencies.superReferencedNames, superPrefixed);
 
     var actualMembers = dependencies.classMemberReferences;
     if (actualMembers.length != expectedMembers.length) {
@@ -794,22 +1184,24 @@
       var expectedMember = expectedMembers[i];
       if (actualMember.target.libraryUri != expectedMember.targetUri ||
           actualMember.target.name != expectedMember.targetName ||
-          actualMember.name != expectedMember.name ||
-          actualMember.targetSuper != expectedMember.withSuper) {
+          actualMember.name != expectedMember.name) {
         fail('Expected: $expectedMember\nActual: $actualMember');
       }
     }
   }
 
   void _assertImpl(Library library, String name, NodeKind kind,
-      {List<String> unprefixed: const [],
+      {String memberOf,
+      List<String> unprefixed: const [],
       Map<String, List<String>> prefixed: const {},
+      List<String> superPrefixed: const [],
       List<_ExpectedClassMember> expectedMembers: const []}) {
-    var node = getNode(library, name: name, kind: kind);
+    var node = getNode(library, name: name, kind: kind, memberOf: memberOf);
     _assertDependencies(
       node.impl,
       unprefixed: unprefixed,
       prefixed: prefixed,
+      superPrefixed: superPrefixed,
       expectedMembers: expectedMembers,
     );
   }
@@ -818,14 +1210,16 @@
 class _ExpectedClassMember {
   final Uri targetUri;
   final String targetName;
-  final bool withSuper;
   final String name;
 
-  _ExpectedClassMember(this.targetUri, this.targetName, this.name,
-      {this.withSuper: false});
+  _ExpectedClassMember(
+    this.targetUri,
+    this.targetName,
+    this.name,
+  );
 
   @override
   String toString() {
-    return '($targetUri, $targetName, $name, withSuper: $withSuper)';
+    return '($targetUri, $targetName, $name)';
   }
 }