anchor.diff:    // TODO(eernst): Rename this to `parseTypeNotVoidWithoutFunction`?
     // Apparently,  it was named `parseTypeName` before type arguments existed.
     TypeName parseTypeName(bool inExpression) {
  -    TypeName realType = _parseTypeName(inExpression);
  -    // If this is followed by a generic method type comment, allow the comment
  -    // type to replace the real type name.
  -    // TODO(jmesserly): this feels like a big hammer. Can we restrict it to
  -    // only work inside generic methods?
  -    TypeName typeFromComment = _parseOptionalTypeNameComment();
  -    return typeFromComment ?? realType;
  +    return _parseTypeName(inExpression);
     }
   
     /**
  
positive.code:     return null;
    }
  
    bool _injectGenericComment(TokenType type, int prefixLen) {
      if (parseGenericMethodComments) {
        CommentToken t = _currentToken.precedingComments;
        for (; t != null; t = t.next) {
          if (t.type == type) {
            String comment = t.lexeme.substring(prefixLen, t.lexeme.length - 2);
            Token list = _scanGenericMethodComment(comment, t.offset + prefixLen);
            if (list != null) {
              _reportErrorForToken(HintCode.GENERIC_METHOD_COMMENT, t);
              // Remove the token from the comment stream.
              t.remove();
              // Insert the tokens into the stream.
              _injectTokenList(list);
              return true;
            }
          }
        }
      }
      return false;
    }
  
    /**
     * Matches a generic comment type substitution and injects it into the token
     * stream. Returns true if a match was injected, otherwise false.
     *
     * These comments are of the form `/*=T*/`, in other words, a [TypeName]
     * inside a slash-star comment, preceded by equals sign.
     */
    bool _injectGenericCommentTypeAssign() {
      return _injectGenericComment(TokenType.GENERIC_METHOD_TYPE_ASSIGN, 3);
    }
  
    /**
     * Matches a generic comment type parameters and injects them into the token
     * stream. Returns true if a match was injected, otherwise false.
     *
     * These comments are of the form `/*<K, V>*/`, in other words, a
     * [TypeParameterList] or [TypeArgumentList] inside a slash-star comment.
     */
    bool _injectGenericCommentTypeList() {
      return _injectGenericComment(TokenType.GENERIC_METHOD_TYPE_LIST, 2);
    }
  
    /**
     * Inject the given [token] into the token stream immediately before the
     * current token.
  
negative.code:   }
  
    /**
     * Parse the generic method or function's type parameters.
     *
     * For backwards compatibility this can optionally use comments.
     * See [parseGenericMethodComments].
     */
    TypeParameterList _parseGenericMethodTypeParameters() {
      if (_matches(TokenType.LT)) {
        return parseTypeParameterList();
      }
      return null;
  