From b663f2400994df3ffda58fbb7c80d6e8169e4086 Mon Sep 17 00:00:00 2001
From: choiminyeong <choiminyeong@ubisam.com>
Date: Mon, 28 Sep 2026 16:07:46 +0900
Subject: [PATCH] TASK-058: outline for C++ with CRLF line endings, macros and
 #if blocks

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 .../ubgitea/feature/codebrowser/CodePane.kt   |   4 +-
 .../codebrowser/content/SymbolOutline.kt      |  27 ++++++-
 .../codebrowser/content/SymbolOutlineTest.kt  |  58 +++++++++++++++
 docs/UBGitea_기술소개.pptx                    | Bin 725853 -> 725853 bytes
 docs/development-log.md                       |  11 +++
 tasks/058-outline-for-windows-cpp.md          |  69 ++++++++++++++++++
 6 files changed, 167 insertions(+), 2 deletions(-)
 create mode 100644 tasks/058-outline-for-windows-cpp.md

diff --git a/app/src/main/java/com/ubisam/ubgitea/feature/codebrowser/CodePane.kt b/app/src/main/java/com/ubisam/ubgitea/feature/codebrowser/CodePane.kt
index 01a1a4b..7fa6add 100644
--- a/app/src/main/java/com/ubisam/ubgitea/feature/codebrowser/CodePane.kt
+++ b/app/src/main/java/com/ubisam/ubgitea/feature/codebrowser/CodePane.kt
@@ -81,7 +81,9 @@ class CodeDocument(
 fun rememberCodeDocument(path: RepositoryPath, text: String): CodeDocument {
     val colors = rememberCodeSyntaxColors()
     val language = remember(path) { syntaxLanguageForPath(path) }
-    val lines = remember(text) { text.split("\n") }
+    // Files written on Windows end their lines with "\r\n". The "\r" is not part of the line: left
+    // in, it is an invisible last character that no declaration pattern expects (TASK-058).
+    val lines = remember(text) { text.split("\n").map { it.removeSuffix("\r") } }
     val plain = remember(path, lines) {
         CodeDocument(path, language, lines, lines.map(::AnnotatedString), emptyList(), lines.maxOfOrNull(String::length) ?: 0)
     }
diff --git a/app/src/main/java/com/ubisam/ubgitea/feature/codebrowser/content/SymbolOutline.kt b/app/src/main/java/com/ubisam/ubgitea/feature/codebrowser/content/SymbolOutline.kt
index 210be31..ae7b7b7 100644
--- a/app/src/main/java/com/ubisam/ubgitea/feature/codebrowser/content/SymbolOutline.kt
+++ b/app/src/main/java/com/ubisam/ubgitea/feature/codebrowser/content/SymbolOutline.kt
@@ -34,13 +34,27 @@ private val OUTLINE_LANGUAGES = setOf(SyntaxLanguage.CSHARP, SyntaxLanguage.CPP,
  */
 fun extractSymbols(lines: List<String>, language: SyntaxLanguage): List<CodeSymbol> {
     if (!supportsOutline(language)) return emptyList()
-    val code = blankCommentsAndStrings(lines, language)
+    val source = lines.map { it.removeSuffix("\r") }
+    val code = blankCommentsAndStrings(source, language)
     val symbols = mutableListOf<Pending>()
     val scopes = ArrayDeque<Scope>()
+    // How deep the scopes were where each open `#if` began.
+    val conditionals = ArrayDeque<Int>()
     var awaitingBody: Pending? = null
     var linesAwaited = 0
 
     code.forEachIndexed { index, line ->
+        // Only one branch of an `#if` is compiled, but all of them are read here. When each branch
+        // opens the same block (`#ifdef A` / `if (x) {` / `#else` / `if (y) {` / `#endif`), counting
+        // both braces would leave a scope that never closes and hide the rest of the file. So each
+        // further branch starts from the depth the first one started from.
+        when (directiveOf(source[index])) {
+            "if", "ifdef", "ifndef" -> conditionals.addLast(scopes.size)
+            "else", "elif", "elifdef", "elifndef" -> conditionals.lastOrNull()?.let { depth ->
+                while (scopes.size > depth) scopes.removeLast()
+            }
+            "endif" -> conditionals.removeLastOrNull()
+        }
         val enclosing = scopes.lastOrNull()?.kind
         val canDeclare = enclosing == null || enclosing == ScopeKind.NAMESPACE || enclosing == ScopeKind.TYPE
         if (awaitingBody != null && ++linesAwaited > MAX_LINES_AWAITING_BODY) awaitingBody = null
@@ -142,6 +156,14 @@ private class Pending(val found: Found, val line: Int, val depth: Int) {
 
 private class Found(val name: String, val label: String, val kind: SymbolKind)
 
+private val DIRECTIVE = Regex("^\\s*#\\s*([a-z]+)")
+
+private fun directiveOf(line: String): String? = DIRECTIVE.find(line)?.groupValues?.get(1)
+
+// `DECLARE_MESSAGE_MAP()`, `Q_OBJECT`-style: written like a call, named in capitals, and -- unlike
+// a declaration -- often not followed by `;`.
+private val MACRO_NAME = Regex("[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*")
+
 private fun blankCommentsAndStrings(lines: List<String>, language: SyntaxLanguage): List<String> =
     tokenizeLines(lines, language).mapIndexed { index, tokens ->
         val characters = lines[index].toCharArray()
@@ -225,6 +247,9 @@ private fun cppDeclaration(line: String, trimmed: String, firstWord: String, ins
             // `Name(...)` is a constructor or a macro-declared function. A free-standing call
             // (`DoThing(x);` at namespace level) is not valid C++, so it cannot be one.
             val isConstructorLike = insideType || "::" in qualified
+            // A macro invocation in a class body is not a member, and as it has no `;` it would
+            // also swallow the declaration on the next line while a body was waited for.
+            if (!hasReturnType && "::" !in qualified && name.length > 1 && MACRO_NAME.matches(name)) return null
             if (name !in STATEMENT_WORDS && (hasReturnType || isConstructorLike)) {
                 return Found(name, name + parameterTypes(match.groupValues[2]), SymbolKind.METHOD)
             }
diff --git a/app/src/test/java/com/ubisam/ubgitea/feature/codebrowser/content/SymbolOutlineTest.kt b/app/src/test/java/com/ubisam/ubgitea/feature/codebrowser/content/SymbolOutlineTest.kt
index 715750b..02591e5 100644
--- a/app/src/test/java/com/ubisam/ubgitea/feature/codebrowser/content/SymbolOutlineTest.kt
+++ b/app/src/test/java/com/ubisam/ubgitea/feature/codebrowser/content/SymbolOutlineTest.kt
@@ -99,6 +99,64 @@ class SymbolOutlineTest {
         assertTrue(symbols.none { it.name == "public" || it.name == "private" })
     }
 
+    @Test
+    fun `lines ending in a carriage return are read like any other`() {
+        val header = "class A\r\n{\r\npublic:\r\n\tvoid F(int a);\r\n};\r\n".split("\n")
+        val source = "void A::F(int a)\r\n{\r\n}\r\n".split("\n")
+        val sharp = "public class A\r\n{\r\n    public void F()\r\n    {\r\n    }\r\n}\r\n".split("\n")
+
+        assertEquals(listOf("A", "F(int)"), extractSymbols(header, SyntaxLanguage.CPP).map { it.label })
+        assertEquals(listOf("F(int)"), extractSymbols(source, SyntaxLanguage.CPP).map { it.label })
+        assertEquals(listOf("A", "F()"), extractSymbols(sharp, SyntaxLanguage.CSHARP).map { it.label })
+    }
+
+    @Test
+    fun `a macro in a class body is not a method and does not hide the declaration after it`() {
+        val lines = """
+            class CMainDlg : public CDialogEx
+            {
+                DECLARE_DYNAMIC(CMainDlg)
+            public:
+                CMainDlg(CWnd* pParent = NULL);
+                virtual ~CMainDlg();
+                DECLARE_MESSAGE_MAP()
+            public:
+                afx_msg void OnBnClickedOk();
+            };
+        """.trimIndent().lines()
+
+        assertEquals(
+            listOf("CMainDlg", "CMainDlg(CWnd*)", "~CMainDlg()", "OnBnClickedOk()"),
+            extractSymbols(lines, SyntaxLanguage.CPP).map { it.label },
+        )
+    }
+
+    @Test
+    fun `a block opened in both branches of a conditional is counted once`() {
+        val lines = """
+            BOOL CMainDlg::PreTranslateMessage(MSG* pMsg)
+            {
+            #ifdef A
+                if (x) {
+            #else
+                if (y) {
+            #endif
+                }
+                return TRUE;
+            }
+
+            int After(int a)
+            {
+                return a;
+            }
+        """.trimIndent().lines()
+
+        val symbols = extractSymbols(lines, SyntaxLanguage.CPP)
+
+        assertEquals(listOf("PreTranslateMessage(MSG*)", "After(int)"), symbols.map { it.label })
+        assertEquals(9, symbols.first().endLine)
+    }
+
     @Test
     fun `a forward declaration is not listed`() {
         val symbols = extractSymbols(listOf("class Foo;"), SyntaxLanguage.CPP)
diff --git a/docs/UBGitea_기술소개.pptx b/docs/UBGitea_기술소개.pptx
index e3b577ff0cb21c14e5a8c7bcdce22965684fa3a1..6eef4fc53daf3641e3a271659c87e895f387179d 100644
GIT binary patch
delta 2953
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
a{Zmc@XTXFQT9?Jpx;4hYX%;=oSoDAYiE-Ni

delta 2954
zcmY*aYgAO%73SVM_rbY5W-tq)qxgt176$|cQ9uQfXbCE%YLHZsR*h!qLSj=*0`ZY*
zvNSPB2XY!>Bh->u!&2k8a;+(aHcefNh6EA~F)m+V+O*Mj21MRW@80|9TAd%W?>Xn&
z-}mja@9eqquII|Tp0FR~Dh?I`pSMyf!=}jgcjCkFT`<Z1_Lj)el@(4{*F6I3h4%V-
z46Fxch;wg-1OWTU?R`dyg2x+@oBzI#Mf@K-0$T3@W&=lEwAUlMC^;TNi9C%~(cT6b
zWNfNv?`3%cJPyhp2-B5WcJQrMM&mFh?3E#QCN}EETPYc9R+T@u%lF>gS7d!oT5@t)
zN|HA@ecAoz{prboZc3jT3Gv$}MxajL&CQ!}onN*@ve(`t<=?{gD=)245VrdkihTLY
zT~Y*yxRm0;9Ct`aj+<v)l%jpx_pNdRu&uUAMi&V+HI@8Yk37xytD{FW-1;aj%fSN`
zvd6dK_%%@REox}|As)RtEB*w}Ymuh-;(I&s$kq3E4Io!XT&NrfcCSNdZGkZpp}c93
zF`izfrdn-Bja?FN-5^2#tiT2dbFDvZkuce6FOjzY1deiABu4(W|NL+e{qdd>Da)Gl
zg<+~zYrC{uLY1Z`UN_MzuNh{{D*95o2)3-0i_*cBi14c^N6?3LD^5nwR+~pA;or=*
zy9)4ADROZ>!oO~qah~95uL^kVegXf!Lcm8W<<_;3*BX!+5?t!BF-TCp@xim`s5--B
zJQ$EuEoZX)g5*tz)cCK5<%y8@hhbSNf`>morHDeGi8^<c3Y{p~B@V1sYKXA3FYg!<
zTIbg(*bnR22E|QwUGFWJN_KC5s8Dt7XBDdMohF5<`{2(?>_$*)pY8}lyVv3zt<W~>
zM3Q5SjBm=mvA55a?F<Pi+sR8C9WmBFW;+h-#EP2F@N^ztq&;N4ecI85*Sq_S$j|%8
z&Ih9PjgGlb!^1ldsie{Huu2+b9+fbM64Z*-fSLT7z|1@-Fr!`@gFfb8s83#57!tCw
zkbKN}Q(a#ONr(SyC!wKzHHnS9GDCmF>IkT{bW3{{Uils0<5A<ShJN)rntWqW-LVcb
z^&(AV#^evZh?)FUsC~(ci?z2Yy?JVW3#G?w)F^#mla__)8K2%uzixi@FB0DInI?pl
z&`(~#OuoRh8@}~ZO*EWq9ojUIPw3E=BGF4}I$h0c8G0+}W=G}3knX`pb<*AXxc=7z
zSZCqwrcHG5MQwT)z3??d(TB-G=@+`Nu<Yenok$+PWRqZS{kV>OR{Uk%A1lrBPOh54
zPpyzoSbc+fze`HIx3QQzKbALHE#by*VQN|>DFzuVPc^7_xeE;HU2&%2pda>`jcY5w
z)fDTEqsC2AJKk-jf~#p(ZM{)PrFAXOJ`b)u)-M{28-&YTv3Q<Ubi$~2O0z6SlQ9M+
zvNiT|gHvbc&MWs5&((ID2M+gqEgZc0jd39scD4){8oqPS4H=a%aV>pp=r(M5*|^XP
z|Aw7>m36=akMlDa!@S7PQXp3QSt7(OJ#0Mh^0RTU2>Mwn#L{kib47qnhQ*EmOTUk7
z3lI_!MmHf&0(@~dgS&&=`4H{RM<Lpr<GHhk!MG*joE}QErRUt=Y!;iy73?9d>33KL
zAfCR%vLPP7!xlpP{to$^+RHMq%kUq<H}%qPT`$W8)PH(eCd9<M6t~?aXCK@pmTs|5
z>SId*x4Vz6g7{4z%YrzepDls7xu4~t3jQG!53^`~p`WF}k#m4$;Sv5JB#qifTL<W3
z>js320rn(77Yzz1{vjZ=evl<%cCK0e34gZV&h8mxGjVHPSm7m(TA4$nRX#+vnuf?$
z_%I1PHB17hhlK!6dK7St2!Wet3+9r*+7UJr>>L`QtnWsMb;c-Lg2H1uUwogS)uY18
z{PL==$V=xad5H~D)=z`v<z$e&3<r_5dWA{XGUqSudJa~qeI}KP;~h(tB$G<T!H%Ua
zlT5tU1CogyXq8OtfLk`H14*|&{u?>jD-*O?HnY+9Kif~A<F%$4%_k{l5^m+49eIFf
z8TQsz#l*M0PB9Ch`a#9S7ixjS#MU2lkkDlZohPe;^}7lC*AZ)#Dp=!w;Lar0E>#q@
z=x2K$<To6)P?BcikEKKt1fM_O&`AWJX=V~=OFC)g>7;c`Coi{j@{(?t)CnBr$Xag@
zYo{StkHl5}m{_wzg)JQESZrmeu!X}M39f|_!FWbm#f-F0GV(IQ$jg%^o!6M=QoO=#
z%@Y!+ST#(r;;2T}<zd8nC`{PGL5)4|hY4Far_t8JaO%Oc;bsAH!)WGh;U@mXBO=Jr
znh0|AegrvkL<(*kx5&LdQgGw6MQ&fDFo(ky%}Gu(9c5tF^2eMc^Rkm<+MOgb(M2-P
cyJ-Ks%fuNlIf~Y$QM7J}GI5$kjxm@04?pA=mH+?%

diff --git a/docs/development-log.md b/docs/development-log.md
index e37ec35..d2fd6d9 100644
--- a/docs/development-log.md
+++ b/docs/development-log.md
@@ -1381,3 +1381,14 @@ This is the append-only implementation and handoff record shared by Codex and Cl
 - Live verification: installed on the SM-F966N. None of it has been seen on a screen by the
   implementer.
 - Next owner: the product owner, to confirm on the device.
+
+## 2026-09-28 (continued) — TASK-058: the outline was empty for C++ written on Windows
+
+- Request: the human product owner reported that a `.cpp` and `.h` showed no classes or functions.
+- Cause and change: see `tasks/058-outline-for-windows-cpp.md`. The main cause was `\r\n` line
+  endings; the viewer kept the `\r` on every line, and no method pattern matched. This affected
+  C# files with `\r\n` endings too.
+- Checks and results: the required checks pass; 435 unit tests, 0 failures; lint 0 errors.
+- Live verification: installed on the SM-F966N; reproduced and fixed in unit tests only, not on
+  the owner's files.
+- Next owner: the product owner, to confirm on the files they were reading.
diff --git a/tasks/058-outline-for-windows-cpp.md b/tasks/058-outline-for-windows-cpp.md
new file mode 100644
index 0000000..fcd60e4
--- /dev/null
+++ b/tasks/058-outline-for-windows-cpp.md
@@ -0,0 +1,69 @@
+# TASK-058: The outline was empty for C++ written on Windows
+
+Status: implemented; required checks pass; installed on the product owner's Z Fold7, awaiting their confirmation
+Owner: Claude
+Reviewer: human product owner
+
+## Outcome
+
+The human product owner reported that a `.cpp` and its `.h` showed no classes or functions in the
+side pane, although both plainly contain them.
+
+## Cause
+
+Reproduced in a unit test, not on the owner's files (their repository is private and was not read).
+
+1. Lines ending in `\r\n`. The viewer split text on `\n` only, so every line of a file written on
+   Windows ended in an invisible `\r`. The patterns that recognize a method must match a whole
+   line, and `.` does not match `\r`, so no method was ever recognized -- in C++ and in C# alike.
+   A class was still found, because that pattern only has to match the start of the line. A `.cpp`
+   holding only function definitions therefore had an empty outline.
+2. Found while reproducing, in MFC-style code: a macro in a class body (`DECLARE_MESSAGE_MAP()`)
+   was listed as a method, and because it has no `;` the declaration on the next line was skipped.
+3. Found while reproducing: a block opened in both branches of an `#if`/`#else` was counted twice,
+   leaving a scope that never closed; every function after it in the file was missing.
+
+## Scope
+
+- Included: the three causes above, with a test for each.
+- Excluded: declarations produced by macros, and declarations split across lines before their
+  name. The outline recognizes patterns; it is not a parser.
+
+## Writable paths
+
+- `app/src/main/java/com/ubisam/ubgitea/feature/codebrowser/`
+- `app/src/test/java/com/ubisam/ubgitea/feature/codebrowser/`
+- `tasks/`, `docs/`
+
+## Acceptance criteria
+
+- [x] A header, a source file and a C# file with `\r\n` line endings list their methods.
+- [x] A capitalized macro in a class body is not listed and does not hide what follows it.
+- [x] A block opened in each branch of a conditional is counted once.
+
+## Security and privacy
+
+No additional concerns.
+
+## Required checks
+
+```text
+./gradlew compileDebugKotlin compileDebugUnitTestKotlin testDebugUnitTest assembleDebug lintDebug
+```
+
+## Evidence
+
+- Required checks pass: 435 unit tests, 0 failures; lint 0 errors.
+- Installed on the SM-F966N over wireless `adb`.
+- Not verified against the files the product owner was reading. If their outline is still empty,
+  the cause is something these three do not cover, and a sample of the file is needed.
+
+## Known limitations
+
+- A header whose class showed nothing at all is not explained by cause 1, which still finds
+  classes. It may be explained by the owner looking at the `.cpp`'s outline while both were open.
+- Removing the `\r` also changes what "copy" puts on the clipboard: lines are joined as displayed.
+
+## Review findings
+
+None yet.