Support full code diff in modification

Author: intitni

Core/Sources/SuggestionWidget/SuggestionPanelContent/PromptToCodePanelView.swift

@@ -611,20 +611,18 @@ extension PromptToCodePanelView {
                 var body: some View {
                     WithPerceptionTracking {
                         let startLineIndex = store.snippet.attachedRange.start.line
-                        AsyncCodeBlock(
+                        AsyncDiffCodeBlock(
                             code: store.snippet.modifiedCode,
                             originalCode: store.snippet.originalCode,
                             language: language.rawValue,
                             startLineIndex: startLineIndex,
                             scenario: "promptToCode",
                             font: codeFont.value.nsFont,
                             droppingLeadingSpaces: hideCommonPrecedingSpaces,
-                            proposedForegroundColor: codeForegroundColor,
-                            ignoreWholeLineChangeInDiff: false
+                            proposedForegroundColor: codeForegroundColor
                         )
-                        .frame(maxWidth: .infinity)
-
-                        .scaleEffect(x: 1, y: -1, anchor: .center)
+                        .frame(maxWidth: CGFloat.infinity)
+                        .scaleEffect(x: 1, y: -1, anchor: UnitPoint.center)
                     }
                 }
             }

Tool/Sources/CodeDiff/CodeDiff.swift

@@ -85,7 +85,7 @@ public struct CodeDiff {
         }
 
         public var description: String {
-            "Diff:\n" + sections.map(\.description).joined(separator: "\n") + "\n"
+            "Diff:\n" + sections.map(\.description).joined(separator: "\n---\n") + "\n"
         }
     }
 
@@ -154,6 +154,31 @@ public struct CodeDiff {
             let removalSection = removals[safe: sectionIndex]
             let insertionSection = insertions[safe: sectionIndex]
 
+            if removalSection == nil, insertionSection == nil {
+                let finishingSection = SnippetDiff.Section(
+                    oldOffset: oldLineIndex,
+                    newOffset: newLineIndex,
+                    oldSnippet: {
+                        guard oldLineIndex < oldLines.endIndex else { return [] }
+                        return oldLines[oldLineIndex..<oldLines.endIndex].map {
+                            .init(text: String($0), diff: .unchanged)
+                        }
+                    }(),
+                    newSnippet: {
+                        guard newLineIndex < newLines.endIndex else { return [] }
+                        return newLines[newLineIndex..<newLines.endIndex].map {
+                            .init(text: String($0), diff: .unchanged)
+                        }
+                    }()
+                )
+
+                if !finishingSection.isEmpty {
+                    result.sections.append(finishingSection)
+                }
+
+                break
+            }
+
             // handle lines before sections
             var beforeSection = SnippetDiff.Section(
                 oldOffset: oldLineIndex,
@@ -162,7 +187,7 @@ public struct CodeDiff {
                 newSnippet: []
             )
 
-            while oldLineIndex < (removalSection?.offset ?? oldLines.endIndex) {
+            while oldLineIndex < (removalSection?.offset ?? (sectionIndex == 0 ? 0 : oldLines.endIndex)) {
                 if oldLineIndex < oldLines.endIndex {
                     beforeSection.oldSnippet.append(.init(
                         text: String(oldLines[oldLineIndex]),
@@ -171,7 +196,7 @@ public struct CodeDiff {
                 }
                 oldLineIndex += 1
             }
-            while newLineIndex < (insertionSection?.offset ?? newLines.endIndex) {
+            while newLineIndex < (insertionSection?.offset ?? (sectionIndex == 0 ? 0 : newLines.endIndex)) {
                 if newLineIndex < newLines.endIndex {
                     beforeSection.newSnippet.append(.init(
                         text: String(newLines[newLineIndex]),
@@ -182,6 +207,7 @@ public struct CodeDiff {
             }
 
             if !beforeSection.isEmpty {
+//                print("before section\n\n",beforeSection)
                 result.sections.append(beforeSection)
             }
 
@@ -218,13 +244,14 @@ public struct CodeDiff {
                 }
             }
 
-            if !insideSection.isEmpty {
-                result.sections.append(insideSection)
-            }
-
             oldLineIndex += removalSection?.lines.count ?? 0
             newLineIndex += insertionSection?.lines.count ?? 0
             sectionIndex += 1
+
+            if !insideSection.isEmpty {
+//                print("inside section\n\n", insideSection)
+                result.sections.append(insideSection)
+            }
         }
 
         return result

Tool/Sources/SharedUIComponents/AsyncDiffCodeBlock.swift

@@ -230,21 +230,27 @@ extension AsyncDiffCodeBlock {
 
             for section in diffResult.sections {
                 guard !section.isEmpty else { continue }
-                let startIndex = section.oldOffset
-                let endIndex = section.oldOffset + section.oldSnippet.count
-
-                let oldLines = originalHighlightedCode[startIndex..<endIndex]
-                lines.append(contentsOf: oldLines.enumerated().map {
-                    Line(index: $0 + startIndex, kind: .deleted, string: $1)
-                })
-
-                let newStartIndex = section.newOffset
-                let newEndIndex = section.newOffset + section.newSnippet.count
+             
+                for (index, line) in section.oldSnippet.enumerated() {
+                    if line.diff == .unchanged { continue }
+                    let lineIndex = section.oldOffset + index
+                    if lineIndex >= 0, lineIndex < originalHighlightedCode.count {
+                        let oldLine = originalHighlightedCode[lineIndex]
+                        lines.append(Line(index: lineIndex, kind: .deleted, string: oldLine))
+                    }
+                }
 
-                let newLines = highlightedCode[newStartIndex..<newEndIndex]
-                lines.append(contentsOf: newLines.enumerated().map {
-                    Line(index: $0 + newStartIndex, kind: .added, string: $1)
-                })
+                for (index, line) in section.newSnippet.enumerated() {
+                    let lineIndex = section.newOffset + index
+                    guard lineIndex >= 0, lineIndex < highlightedCode.count else { continue }
+                    if line.diff == .unchanged {
+                        let newLine = highlightedCode[lineIndex]
+                        lines.append(Line(index: lineIndex, kind: .unchanged, string: newLine))
+                    } else {
+                        let newLine = highlightedCode[lineIndex]
+                        lines.append(Line(index: lineIndex, kind: .added, string: newLine))
+                    }
+                }
             }
 
             return lines
@@ -384,8 +390,8 @@ extension AsyncDiffCodeBlock {
 
 #Preview("Multiple Line Suggestion") {
     AsyncDiffCodeBlock(
-        code: "    let foo = Bar()\n    print(foo)",
-        originalCode: "    var foo // comment\n    print(bar)",
+        code: "    let foo = Bar()\n    print(foo)\n    print(a)",
+        originalCode: "    var foo // comment\n    print(bar)\n    print(a)",
         language: "swift",
         startLineIndex: 10,
         scenario: "",
@@ -397,8 +403,8 @@ extension AsyncDiffCodeBlock {
 }
 
 #Preview("Multiple Line Suggestion Including Whole Line Change in Diff") {
-    AsyncCodeBlock(
-        code: "// comment\n    let foo = Bar()\n    print(bar)\n    print(foo)",
+    AsyncDiffCodeBlock(
+        code: "// comment\n    let foo = Bar()\n    print(bar)\n    print(foo)\n",
         originalCode: "    let foo = Bar()\n",
         language: "swift",
         startLineIndex: 10,