fix(link): robust main-detection (strip strings/comments) — fixes Windows LNK1561

The per-consumer archive-vs-inline decision scanned source text line-by-line for
'int main(', which false-positived on test fixtures embedding "int main(){}"
as a STRING (test_modgraph.cpp). That wrongly picked archive linking for a
no-main test → MSVC lld-link doesn't pull gtest_main.o for the entry → LNK1561.
(On ELF/Mach-O the archive member IS pulled, so Linux/macOS masked the bug.)

source_defines_main now strips comments + string/char/raw-string literals via a
char state machine before matching int/auto main(. Exported + unit-tested
(test_main_detection.cpp: string/raw-string/comment fixtures must NOT count).

Author: Sunrisepeak

.agents/docs/2026-06-25-dependency-archive-linking-design.md

@@ -92,8 +92,11 @@ LINK : fatal error LNK1561: entry point must be defined
 | 是 | **归档** `lib<pkg>.a`(排在对象后) | 链接器不拉 `gtest_main.o`(main 已定义)→ 无 `duplicate main`;入口由测试提供,MSVC 也 OK |
 | 否 | **直接内联**依赖的非模块对象 | `gtest_main.o` 作为普通对象直接提供入口 → **任何**链接器(含 MSVC)都 OK;测试无 main 故无冲突 |
 
-判据 = **扫描消费者入口源是否定义 `int main`/`auto main`**(空白不敏感、跳过注释行;
-启发式,最坏只是选错链接方式而非出错;探测不到时默认按「无 main」内联=改动前行为)。
+判据 = **扫描消费者入口源是否定义 `int main`/`auto main`**(`source_defines_main`:先
+用字符状态机**剥离注释、字符串、字符、raw-string 字面量**再匹配——否则测试夹具里的
+`"int main(){...}"` 字符串会假阳性,导致对 no-main 测试错选归档 → MSVC LNK1561,正是
+`test_modgraph.cpp` 踩中的坑;启发式,最坏只是选错链接方式而非出错;探测不到时默认按
+「无 main」内联=改动前行为)。
 **通用**:无需识别「哪个依赖对象提供 main」,只看消费者自己——对任何 `kind="lib"`
 依赖、任何未来测试框架都成立。
 

src/build/plan.cppm

@@ -77,6 +77,11 @@ struct BuildPlan {
     std::vector<CapabilityProvider>    runtimeProviders;
 };
 
+// True if a source file defines a top-level `int main(`/`auto main(` entry,
+// ignoring comments and string/raw-string literals. Drives the archive-vs-inline
+// choice for kind="lib" dependencies (see plan.cppm).
+bool source_defines_main(const std::filesystem::path& src);
+
 // Build a BuildPlan from already-validated inputs.
 BuildPlan make_plan(const mcpp::manifest::Manifest&         manifest,
                     const mcpp::toolchain::Toolchain&       tc,
@@ -212,6 +217,70 @@ void append_unique_path(std::vector<std::filesystem::path>& out,
 
 } // namespace
 
+// True if `src` defines a top-level `int main(` / `auto main(` entry point.
+// Comments and string/char/raw-string literals are stripped first, so test
+// fixtures that embed `"int main() {...}"` or R"(int main(){})" don't
+// false-positive (that misfire chose archive linking for a no-main test →
+// gtest_main.o not pulled by MSVC lld-link → LNK1561). Heuristic but robust;
+// worst case is a sub-optimal archive-vs-inline choice, never a miscompile.
+bool source_defines_main(const std::filesystem::path& src) {
+    std::ifstream is(src);
+    if (!is) return false;
+    std::string raw((std::istreambuf_iterator<char>(is)),
+                    std::istreambuf_iterator<char>());
+    std::string code;
+    code.reserve(raw.size());
+    enum State { Normal, Line, Block, Str, Chr, RawStr } st = Normal;
+    std::string rawEnd;  // ")delim\"" terminator for the active raw string
+    for (std::size_t i = 0; i < raw.size(); ++i) {
+        char c = raw[i];
+        char n = (i + 1 < raw.size()) ? raw[i + 1] : '\0';
+        switch (st) {
+        case Normal:
+            if (c == 'R' && n == '"') {
+                std::size_t j = i + 2;
+                std::string delim;
+                while (j < raw.size() && raw[j] != '(') delim.push_back(raw[j++]);
+                rawEnd = ")" + delim + "\"";
+                st = RawStr;
+                i = j;  // sit on '(' ; loop ++ moves past
+            } else if (c == '/' && n == '/') { st = Line; ++i; }
+            else if (c == '/' && n == '*') { st = Block; ++i; }
+            else if (c == '"')  { st = Str; }
+            else if (c == '\'') { st = Chr; }
+            else { code.push_back(c); }
+            break;
+        case Line:  if (c == '\n') { st = Normal; code.push_back(c); } break;
+        case Block: if (c == '*' && n == '/') { st = Normal; ++i; } break;
+        case Str:   if (c == '\\') ++i; else if (c == '"')  st = Normal; break;
+        case Chr:   if (c == '\\') ++i; else if (c == '\'') st = Normal; break;
+        case RawStr:
+            if (raw.compare(i, rawEnd.size(), rawEnd) == 0) {
+                st = Normal;
+                i += rawEnd.size() - 1;
+            }
+            break;
+        }
+    }
+    auto isws = [](char c) {
+        return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f' || c == '\v';
+    };
+    for (std::size_t i = 0; i + 4 <= code.size(); ++i) {
+        if (code.compare(i, 4, "main") != 0) continue;
+        std::size_t p = i;
+        bool sawWs = false;
+        while (p > 0 && isws(code[p - 1])) { --p; sawWs = true; }
+        bool prevOk = sawWs && (
+            (p >= 3 && code.compare(p - 3, 3, "int") == 0) ||
+            (p >= 4 && code.compare(p - 4, 4, "auto") == 0));
+        std::size_t q = i + 4;
+        while (q < code.size() && isws(code[q])) ++q;
+        bool nextOk = q < code.size() && code[q] == '(';
+        if (prevOk && nextOk) return true;
+    }
+    return false;
+}
+
 BuildPlan make_plan(const mcpp::manifest::Manifest&         manifest,
                     const mcpp::toolchain::Toolchain&       tc,
                     const mcpp::toolchain::Fingerprint&     fp,
@@ -546,9 +615,9 @@ BuildPlan make_plan(const mcpp::manifest::Manifest&         manifest,
         // Whether this consumer's own entry source defines `main`. Decides how
         // kind="lib" dependencies are linked (archive vs inline) so the
         // gtest_main-style optional entry works on EVERY linker — see the
-        // dependency-linking block further below. Default false → if we can't
-        // tell, fall back to inlining (the pre-archive behavior).
-        bool entryDefinesMain = false;
+        // dependency-linking block further below. Can't tell (no entry) →
+        // false → inline (the pre-archive behavior, always provides the entry).
+        bool entryDefinesMain = lu.entryMain && source_defines_main(*lu.entryMain);
 
         if ((lu.kind == LinkUnit::Binary || lu.kind == LinkUnit::TestBinary) && lu.entryMain) {
             // Add main.cpp -> obj/main.o
@@ -587,18 +656,6 @@ BuildPlan make_plan(const mcpp::manifest::Manifest&         manifest,
                     }
                     if (!name.empty()) main_cu.imports.push_back(name);
                 }
-                // Detect a top-level `int main(`/`auto main(` definition
-                // (space-insensitive; skip comment lines). Heuristic, but the
-                // worst case is a wrong archive-vs-inline choice, not breakage.
-                if (!entryDefinesMain && !line.starts_with("//") && !line.starts_with("*")) {
-                    std::string nospace;
-                    for (char c : line)
-                        if (!std::isspace(static_cast<unsigned char>(c))) nospace.push_back(c);
-                    if (nospace.find("intmain(") != std::string::npos
-                        || nospace.find("automain(") != std::string::npos) {
-                        entryDefinesMain = true;
-                    }
-                }
             }
 
             // Avoid duplicate insert if main was already scanned

tests/unit/test_main_detection.cpp

@@ -0,0 +1,79 @@
+#include <gtest/gtest.h>
+
+import std;
+import mcpp.build.plan;
+
+using namespace mcpp::build;
+
+namespace {
+
+// Write `content` to a unique temp .cpp and return its path.
+std::filesystem::path write_tmp(std::string_view content, std::string_view tag) {
+    auto dir = std::filesystem::temp_directory_path();
+    auto p = dir / std::format("mcpp_maindetect_{}.cpp", tag);
+    std::ofstream os(p);
+    os << content;
+    os.close();
+    return p;
+}
+
+bool defines_main(std::string_view content, std::string_view tag) {
+    auto p = write_tmp(content, tag);
+    bool r = source_defines_main(p);
+    std::error_code ec;
+    std::filesystem::remove(p, ec);
+    return r;
+}
+
+}  // namespace
+
+TEST(MainDetection, RealMainIsDetected) {
+    EXPECT_TRUE(defines_main("import std;\nint main() { return 0; }\n", "real"));
+}
+
+TEST(MainDetection, RealMainWithArgsIsDetected) {
+    EXPECT_TRUE(defines_main(
+        "int main(int argc, char** argv) { (void)argc; (void)argv; return 0; }\n", "args"));
+}
+
+TEST(MainDetection, AutoMainIsDetected) {
+    EXPECT_TRUE(defines_main("auto main() -> int { return 0; }\n", "automain"));
+}
+
+// The regression: test fixtures embed `"int main() {...}"` as a STRING — that
+// must NOT count as the test binary defining main (it doesn't). A false positive
+// chose archive linking → gtest_main.o not pulled by MSVC lld-link → LNK1561.
+TEST(MainDetection, MainInsideStringLiteralIsIgnored) {
+    EXPECT_FALSE(defines_main(
+        "#include <gtest/gtest.h>\n"
+        "TEST(M, x) {\n"
+        "  auto src = \"int main() { return 0; }\\n\";\n"
+        "  EXPECT_FALSE(src.empty());\n"
+        "}\n", "strlit"));
+}
+
+TEST(MainDetection, MainInsideRawStringIsIgnored) {
+    EXPECT_FALSE(defines_main(
+        "#include <gtest/gtest.h>\n"
+        "TEST(M, x) {\n"
+        "  auto src = R\"(\nint main() { return 0; }\n)\";\n"
+        "  EXPECT_FALSE(src.empty());\n"
+        "}\n", "rawstr"));
+}
+
+TEST(MainDetection, MainInsideCommentIsIgnored) {
+    EXPECT_FALSE(defines_main(
+        "// int main() { return 0; }\n"
+        "#include <gtest/gtest.h>\n"
+        "TEST(M, x) { EXPECT_TRUE(true); }\n", "comment"));
+}
+
+TEST(MainDetection, NoMainGtestStyleIsFalse) {
+    EXPECT_FALSE(defines_main(
+        "#include <gtest/gtest.h>\n"
+        "TEST(M, x) { EXPECT_EQ(1, 1); }\n", "nomain"));
+}
+
+TEST(MainDetection, SimilarIdentifierIsNotMain) {
+    EXPECT_FALSE(defines_main("int mainHelper() { return 0; }\n", "helper"));
+}