anchor.diff:  
     @override
     void visitImportDirective(ImportDirective node) {
  +    var context = 'uri';
       if (node.deferredKeyword != null) {
  -      data.recordTokenType('ImportDirective (uri)', node.deferredKeyword.type);
  -    } else if (node.asKeyword != null) {
  -      data.recordTokenType('ImportDirective (uri)', node.asKeyword.type);
  -    } else if (node.configurations.isNotEmpty) {
  -      _recordTokenType('ImportDirective (uri)', node.configurations[0]);
  -    } else if (node.combinators.isNotEmpty) {
  -      _recordTokenType('ImportDirective (uri)', node.combinators[0]);
  +      data.recordTokenType(
  +          'ImportDirective ($context)', node.deferredKeyword.type);
  +      context = 'deferred';
  +    }
  +    if (node.asKeyword != null) {
  +      data.recordTokenType('ImportDirective ($context)', node.asKeyword.type);
  +      context = 'prefix';
  +    }
  +    if (node.configurations.isNotEmpty) {
  +      _recordTokenType('ImportDirective ($context)', node.configurations[0],
  +          allowedKeywords: importKeywords);
  +      context = 'configurations';
  +    }
  +    if (node.combinators.isNotEmpty) {
  +      _recordTokenType('ImportDirective ($context)', node.combinators[0],
  +          allowedKeywords: importKeywords);
       }
       for (var combinator in node.combinators) {
  -      _recordTokenType('ImportDirective (combinator)', combinator);
  +      _recordTokenType('ImportDirective (combinator)', combinator,
  +          allowedKeywords: importKeywords);
       }
       super.visitImportDirective(node);
     }
   
     @override
     void visitIndexExpression(IndexExpression node) {
  -    _recordDataForNode('IndexExpression (index)', node.index);
  +    _recordDataForNode('IndexExpression (index)', node.index,
  +        allowedKeywords: expressionKeywords);
       _recordTypeMatch(node.index);
       super.visitIndexExpression(node);
     }
  
positive.code:         [data.byTokenType, data.byElementKind, data.byNodeClass],
          ['Token Types', 'Element Kinds', 'Node Classes']);
      sink.writeln('');
      sink.writeln('Argument types match');
      _writeContextMap(sink, data.byTypeMatch);
      sink.writeln('');
      sink.writeln('Distance from reference to declaration');
      _writeContextMap(sink, data.byDistance);
    }
  
    /// Return the minimum widths for each of the columns in the given [table].
  
negative.code: 
    @override
    void visitAwaitExpression(AwaitExpression node) {
      _recordDataForNode('AwaitExpression (expression)', node.expression,
          allowedKeywords: expressionKeywords);
      super.visitAwaitExpression(node);
    }
  
    @override
    void visitBinaryExpression(BinaryExpression node) {
      var operator = node.operator.lexeme;
      _recordDataForNode('BinaryExpression ($operator)', node.rightOperand,
          allowedKeywords: expressionKeywords);
      if (node.operator.isUserDefinableOperator) {
        _recordTypeMatch(node.rightOperand);
      }
  