anchor.diff:     * advancing. Return the return type that was parsed.
      */
     TypeAnnotation _parseOptionalReturnType() {
  -    TypeName typeComment = _parseOptionalTypeNameComment();
  -    if (typeComment != null) {
  -      return typeComment;
  -    }
       Keyword keyword = _currentToken.keyword;
       if (keyword == Keyword.VOID) {
         if (_atGenericFunctionTypeAfterReturnType(_peek())) {
  
positive.code:   // 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;
    }
  
    /**
  
negative.code:     } else if (_tokenMatches(next, TokenType.OPEN_PAREN)) {
        SimpleIdentifier methodName =
            _parseSimpleIdentifierUnchecked(isDeclaration: true);
        TypeParameterList typeParameters = null;
        FormalParameterList parameters = parseFormalParameterList();
        if (methodName.name == className) {
          _reportErrorForNode(ParserErrorCode.CONSTRUCTOR_WITH_RETURN_TYPE, type);
  