anchor.diff:      inheritanceManager = InheritanceManager3();
       featureComputer = FeatureComputer(typeSystem, typeProvider);
   
  +    var hasPrefix = false;
       for (var directive in node.directives) {
  +      if (directive is ImportDirective && directive.prefix != null) {
  +        hasPrefix = true;
  +      }
         _recordTokenType('CompilationUnit (directive)', directive,
             allowedKeywords: directiveKeywords);
       }
  
positive.code:   void recordTypeMatch(String kind, String matchKind) {
      var contextMap = byTypeMatch.putIfAbsent(kind, () => {});
      contextMap[matchKind] = (contextMap[matchKind] ?? 0) + 1;
    }
  
    /// Return a JSON encoded string representing the data that was collected.
    String toJson() {
      return json.encode({
        'version': currentVersion,
        'byDistance': byDistance,
        'byElementKind': byElementKind,
        'byTokenType': byTokenType,
        'byTypeMatch': byTypeMatch,
        'distanceByDepthMap': _encodeIntIntMap(distanceByDepthMap),
      });
    }
  
    /// Add the data in the [source] map to the [target] map.
    void _addToMap<K>(Map<K, Map<K, int>> target, Map<K, Map<K, int>> source) {
      for (var outerEntry in source.entries) {
        var innerTarget = target.putIfAbsent(outerEntry.key, () => {});
        for (var innerEntry in outerEntry.value.entries) {
          var innerKey = innerEntry.key;
          innerTarget[innerKey] = (innerTarget[innerKey] ?? 0) + innerEntry.value;
        }
      }
    }
  
    Map<String, dynamic> _convert(dynamic value) {
      if (value is Map<String, dynamic>) {
        return value;
      }
      throw FormatException('Expected a JSON map.', value);
    }
  
    /// Decode the content of the [source] map into the [target] map, using the
    /// [keyMapper] to map the inner keys from a string to a [T].
    void _decodeIntIntMap(
        Map<int, Map<int, int>> target, Map<String, dynamic> source) {
      var outerMap = _convert(source);
      for (var outerEntry in outerMap.entries) {
        var outerKey = int.parse(outerEntry.key);
        var innerMap = _convert(outerEntry.value);
        for (var innerEntry in innerMap.entries) {
          var innerKey = int.parse(innerEntry.key);
          var count = innerEntry.value as int;
          target.putIfAbsent(outerKey, () => {})[innerKey] = count;
        }
      }
    }
  
    /// Decode the content of the [source] map into the [target] map, using the
    /// [keyMapper] to map the inner keys from a string to a [T].
    void _decodeMap(
        Map<String, Map<String, int>> target, Map<String, dynamic> source) {
      var outerMap = _convert(source);
      for (var outerEntry in outerMap.entries) {
        var outerKey = outerEntry.key;
        var innerMap = _convert(outerEntry.value);
        for (var innerEntry in innerMap.entries) {
          var innerKey = innerEntry.key;
          var count = innerEntry.value as int;
          target.putIfAbsent(outerKey, () => {})[innerKey] = count;
        }
      }
    }
  
    Map<String, Map<String, int>> _encodeIntIntMap(Map<int, Map<int, int>> map) {
      var result = <String, Map<String, int>>{};
      for (var outerEntry in map.entries) {
        var convertedInner = <String, int>{};
        for (var innerEntry in outerEntry.value.entries) {
          convertedInner[innerEntry.key.toString()] = innerEntry.value;
        }
        result[outerEntry.key.toString()] = convertedInner;
      }
      return result;
    }
  
    /// Initialize the state of this object from the given JSON encoded [content].
    void _initializeFromJson(String content) {
      var contentObject = _convert(json.decode(content));
      var version = contentObject['version'].toString();
      if (version != currentVersion) {
        throw StateError(
            'Invalid version: expected $currentVersion, found $version');
      }
      _decodeMap(byDistance, contentObject['byDistance']);
      _decodeMap(byElementKind, contentObject['byElementKind']);
      _decodeMap(byTokenType, contentObject['byTokenType']);
      _decodeMap(byTypeMatch, contentObject['byTypeMatch']);
      _decodeIntIntMap(distanceByDepthMap, contentObject['distanceByDepthMap']);
    }
  }
  
  
negative.code:   @override
    void visitMethodDeclaration(MethodDeclaration node) {
      // There are no completions.
      data.recordPercentage(
          'Methods with type parameters', node.typeParameters != null);
      var element = node.declaredElement;
      if (!element.isStatic && element.enclosingElement is ClassElement) {
        var overriddenMembers = inheritanceManager.getOverridden2(
  