feat(diff): Enable commenting on expanded lines in PR diffs

routers/web/repo/compare.go

@@ -14,6 +14,7 @@ import (
 	"net/http"
 	"net/url"
 	"path/filepath"
+	"sort"
 	"strings"
 
 	"code.gitea.io/gitea/models/db"
@@ -43,6 +44,7 @@ import (
 	"code.gitea.io/gitea/services/context/upload"
 	"code.gitea.io/gitea/services/gitdiff"
 	pull_service "code.gitea.io/gitea/services/pull"
+	user_service "code.gitea.io/gitea/services/user"
 )
 
 const (
@@ -947,6 +949,67 @@ func ExcerptBlob(ctx *context.Context) {
 			section.Lines = append(section.Lines, lineSection)
 		}
 	}
+	if ctx.Doer != nil {
+		ctx.Data["SignedUserID"] = ctx.Doer.ID
+	}
+	isPull := ctx.FormBool("is_pull")
+	ctx.Data["PageIsPullFiles"] = isPull
+
+	if isPull {
+		if !ctx.Repo.CanRead(unit.TypePullRequests) {
+			ctx.NotFound(nil)
+			return
+		}
+		issueIndex := ctx.FormInt64("issue_index")
+		ctx.Data["IssueIndex"] = issueIndex
+		if issueIndex > 0 {
+			if issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, issueIndex); err == nil && issue.IsPull {
+				ctx.Data["Issue"] = issue
+				ctx.Data["CanBlockUser"] = func(blocker, blockee *user_model.User) bool {
+					return user_service.CanBlockUser(ctx, ctx.Doer, blocker, blockee)
+				}
+
+				if allComments, err := issues_model.FetchCodeComments(ctx, issue, ctx.Doer, ctx.FormBool("show_outdated")); err == nil {
+					if lineComments, ok := allComments[filePath]; ok {
+						for _, line := range section.Lines {
+							if comments, ok := lineComments[int64(line.LeftIdx*-1)]; ok {
+								line.Comments = append(line.Comments, comments...)
+							}
+							if comments, ok := lineComments[int64(line.RightIdx)]; ok {
+								line.Comments = append(line.Comments, comments...)
+							}
+							sort.SliceStable(line.Comments, func(i, j int) bool {
+								return line.Comments[i].CreatedUnix < line.Comments[j].CreatedUnix
+							})
+						}
+
+						// Recalculate hidden comment counts for expand buttons after loading comments
+						for _, line := range section.Lines {
+							if line.Type == gitdiff.DiffLineSection && line.SectionInfo != nil {
+								hiddenCommentCount := 0
+								// Check if there are comments in the hidden range
+								for commentLineNum := range lineComments {
+									absLineNum := commentLineNum
+									if absLineNum < 0 {
+										absLineNum = -absLineNum
+									}
+									// Count comments that are in the hidden range
+									if int(absLineNum) > line.SectionInfo.LastRightIdx && int(absLineNum) < line.SectionInfo.RightIdx {
+										hiddenCommentCount++
+									}
+								}
+								if hiddenCommentCount > 0 {
+									line.HasHiddenComments = true
+									line.HiddenCommentCount = hiddenCommentCount
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
 	ctx.Data["section"] = section
 	ctx.Data["FileNameHash"] = git.HashFilePathForWebUI(filePath)
 	ctx.Data["AfterCommitID"] = commitID

services/gitdiff/gitdiff.go

@@ -81,13 +81,15 @@ const (
 
 // DiffLine represents a line difference in a DiffSection.
 type DiffLine struct {
-	LeftIdx     int // line number, 1-based
-	RightIdx    int // line number, 1-based
-	Match       int // the diff matched index. -1: no match. 0: plain and no need to match. >0: for add/del, "Lines" slice index of the other side
-	Type        DiffLineType
-	Content     string
-	Comments    issues_model.CommentList // related PR code comments
-	SectionInfo *DiffLineSectionInfo
+	LeftIdx            int // line number, 1-based
+	RightIdx           int // line number, 1-based
+	Match              int // the diff matched index. -1: no match. 0: plain and no need to match. >0: for add/del, "Lines" slice index of the other side
+	Type               DiffLineType
+	Content            string
+	Comments           issues_model.CommentList // related PR code comments
+	SectionInfo        *DiffLineSectionInfo
+	HasHiddenComments  bool // indicates if this expand button has comments in hidden lines
+	HiddenCommentCount int  // number of hidden comments in this section
 }
 
 // DiffLineSectionInfo represents diff line section meta data
@@ -485,6 +487,25 @@ func (diff *Diff) LoadComments(ctx context.Context, issue *issues_model.Issue, c
 					sort.SliceStable(line.Comments, func(i, j int) bool {
 						return line.Comments[i].CreatedUnix < line.Comments[j].CreatedUnix
 					})
+
+					// Mark expand buttons that have comments in hidden lines
+					if line.Type == DiffLineSection && line.SectionInfo != nil {
+						hiddenCommentCount := 0
+						// Check if there are comments in the hidden range
+						for commentLineNum := range lineCommits {
+							absLineNum := int(commentLineNum)
+							if commentLineNum < 0 {
+								absLineNum = int(-commentLineNum)
+							}
+							if absLineNum > line.SectionInfo.LastRightIdx && absLineNum < line.SectionInfo.RightIdx {
+								hiddenCommentCount++
+							}
+						}
+						if hiddenCommentCount > 0 {
+							line.HasHiddenComments = true
+							line.HiddenCommentCount = hiddenCommentCount
+						}
+					}
 				}
 			}
 		}
@@ -1370,10 +1391,15 @@ outer:
 
 // CommentAsDiff returns c.Patch as *Diff
 func CommentAsDiff(ctx context.Context, c *issues_model.Comment) (*Diff, error) {
+	// If patch is empty, generate it
+	if c.Patch == "" && c.TreePath != "" && c.CommitSHA != "" && c.Line != 0 {
+		return generateCodeContextForComment(ctx, c)
+	}
+
 	diff, err := ParsePatch(ctx, setting.Git.MaxGitDiffLines,
 		setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(c.Patch), "")
 	if err != nil {
-		log.Error("Unable to parse patch: %v", err)
+		log.Error("Unable to parse patch for comment ID=%d: %v", c.ID, err)
 		return nil, err
 	}
 	if len(diff.Files) == 0 {
@@ -1386,6 +1412,97 @@ func CommentAsDiff(ctx context.Context, c *issues_model.Comment) (*Diff, error)
 	return diff, nil
 }
 
+// generateCodeContextForComment creates a synthetic diff showing code context around a comment
+func generateCodeContextForComment(ctx context.Context, c *issues_model.Comment) (*Diff, error) {
+	if err := c.LoadIssue(ctx); err != nil {
+		return nil, fmt.Errorf("LoadIssue: %w", err)
+	}
+	if err := c.Issue.LoadRepo(ctx); err != nil {
+		return nil, fmt.Errorf("LoadRepo: %w", err)
+	}
+	if err := c.Issue.LoadPullRequest(ctx); err != nil {
+		return nil, fmt.Errorf("LoadPullRequest: %w", err)
+	}
+
+	pr := c.Issue.PullRequest
+	if err := pr.LoadBaseRepo(ctx); err != nil {
+		return nil, fmt.Errorf("LoadBaseRepo: %w", err)
+	}
+
+	gitRepo, closer, err := gitrepo.RepositoryFromContextOrOpen(ctx, pr.BaseRepo)
+	if err != nil {
+		return nil, fmt.Errorf("RepositoryFromContextOrOpen: %w", err)
+	}
+	defer closer.Close()
+
+	// Get the file content at the commit
+	commit, err := gitRepo.GetCommit(c.CommitSHA)
+	if err != nil {
+		return nil, fmt.Errorf("GetCommit: %w", err)
+	}
+
+	entry, err := commit.GetTreeEntryByPath(c.TreePath)
+	if err != nil {
+		return nil, fmt.Errorf("GetTreeEntryByPath: %w", err)
+	}
+
+	blob := entry.Blob()
+	dataRc, err := blob.DataAsync()
+	if err != nil {
+		return nil, fmt.Errorf("DataAsync: %w", err)
+	}
+	defer dataRc.Close()
+
+	// Calculate line range (commented line + lines above it)
+	commentLine := int(c.UnsignedLine())
+	contextLines := setting.UI.CodeCommentLines
+	startLine := max(commentLine-contextLines, 1)
+	endLine := commentLine
+
+	// Read only the needed lines efficiently
+	scanner := bufio.NewScanner(dataRc)
+	currentLine := 0
+	var lines []string
+	for scanner.Scan() {
+		currentLine++
+		if currentLine >= startLine && currentLine <= endLine {
+			lines = append(lines, scanner.Text())
+		}
+		if currentLine > endLine {
+			break
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		return nil, fmt.Errorf("scanner error: %w", err)
+	}
+
+	if len(lines) == 0 {
+		return nil, fmt.Errorf("no lines found in range %d-%d", startLine, endLine)
+	}
+
+	// Generate synthetic patch
+	var patchBuilder strings.Builder
+	patchBuilder.WriteString(fmt.Sprintf("diff --git a/%s b/%s\n", c.TreePath, c.TreePath))
+	patchBuilder.WriteString(fmt.Sprintf("--- a/%s\n", c.TreePath))
+	patchBuilder.WriteString(fmt.Sprintf("+++ b/%s\n", c.TreePath))
+	patchBuilder.WriteString(fmt.Sprintf("@@ -%d,%d +%d,%d @@\n", startLine, len(lines), startLine, len(lines)))
+
+	for _, lineContent := range lines {
+		patchBuilder.WriteString(" ")
+		patchBuilder.WriteString(lineContent)
+		patchBuilder.WriteString("\n")
+	}
+
+	// Parse the synthetic patch
+	diff, err := ParsePatch(ctx, setting.Git.MaxGitDiffLines,
+		setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, strings.NewReader(patchBuilder.String()), "")
+	if err != nil {
+		return nil, fmt.Errorf("ParsePatch: %w", err)
+	}
+
+	return diff, nil
+}
+
 // CommentMustAsDiff executes AsDiff and logs the error instead of returning
 func CommentMustAsDiff(ctx context.Context, c *issues_model.Comment) *Diff {
 	if c == nil {

services/pull/review.go

@@ -5,6 +5,7 @@
 package pull
 
 import (
+	"bufio"
 	"context"
 	"errors"
 	"fmt"
@@ -197,6 +198,70 @@ func CreateCodeComment(ctx context.Context, doer *user_model.User, gitRepo *git.
 	return comment, nil
 }
 
+// generatePatchForUnchangedLine creates a patch showing code context for an unchanged line
+func generatePatchForUnchangedLine(gitRepo *git.Repository, commitID, treePath string, line int64, contextLines int) (string, error) {
+	commit, err := gitRepo.GetCommit(commitID)
+	if err != nil {
+		return "", fmt.Errorf("GetCommit: %w", err)
+	}
+
+	entry, err := commit.GetTreeEntryByPath(treePath)
+	if err != nil {
+		return "", fmt.Errorf("GetTreeEntryByPath: %w", err)
+	}
+
+	blob := entry.Blob()
+	dataRc, err := blob.DataAsync()
+	if err != nil {
+		return "", fmt.Errorf("DataAsync: %w", err)
+	}
+	defer dataRc.Close()
+
+	// Calculate line range (commented line + lines above it)
+	commentLine := int(line)
+	if line < 0 {
+		commentLine = int(-line)
+	}
+	startLine := max(commentLine-contextLines, 1)
+	endLine := commentLine
+
+	// Read only the needed lines efficiently
+	scanner := bufio.NewScanner(dataRc)
+	currentLine := 0
+	var lines []string
+	for scanner.Scan() {
+		currentLine++
+		if currentLine >= startLine && currentLine <= endLine {
+			lines = append(lines, scanner.Text())
+		}
+		if currentLine > endLine {
+			break
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		return "", fmt.Errorf("scanner error: %w", err)
+	}
+
+	if len(lines) == 0 {
+		return "", fmt.Errorf("no lines found in range %d-%d", startLine, endLine)
+	}
+
+	// Generate synthetic patch
+	var patchBuilder strings.Builder
+	patchBuilder.WriteString(fmt.Sprintf("diff --git a/%s b/%s\n", treePath, treePath))
+	patchBuilder.WriteString(fmt.Sprintf("--- a/%s\n", treePath))
+	patchBuilder.WriteString(fmt.Sprintf("+++ b/%s\n", treePath))
+	patchBuilder.WriteString(fmt.Sprintf("@@ -%d,%d +%d,%d @@\n", startLine, len(lines), startLine, len(lines)))
+
+	for _, lineContent := range lines {
+		patchBuilder.WriteString(" ")
+		patchBuilder.WriteString(lineContent)
+		patchBuilder.WriteString("\n")
+	}
+
+	return patchBuilder.String(), nil
+}
+
 // createCodeComment creates a plain code comment at the specified line / path
 func createCodeComment(ctx context.Context, doer *user_model.User, repo *repo_model.Repository, issue *issues_model.Issue, content, treePath string, line, reviewID int64, attachments []string) (*issues_model.Comment, error) {
 	var commitID, patch string
@@ -283,6 +348,15 @@ func createCodeComment(ctx context.Context, doer *user_model.User, repo *repo_mo
 			log.Error("Error whilst generating patch: %v", err)
 			return nil, err
 		}
+
+		// If patch is still empty (unchanged line), generate code context
+		if len(patch) == 0 && len(commitID) > 0 {
+			patch, err = generatePatchForUnchangedLine(gitRepo, commitID, treePath, line, setting.UI.CodeCommentLines)
+			if err != nil {
+				log.Warn("Error generating patch for unchanged line: %v", err)
+				// Don't fail comment creation, just leave patch empty
+			}
+		}
 	}
 	return issues_model.CreateComment(ctx, &issues_model.CreateCommentOptions{
 		Type:        issues_model.CommentTypeCode,