feat(emit): baseline and local arguments, private, and config-files

The S1 SHOULD fields the lsp-mcpp validator reads, with values the plan
determines:

- `baseline-arguments` and `local-arguments`. A unit's arguments are its
  driver, the set's baseline, its local arguments and its own trailing
  `-c <source> -o <object>`, whose operands name the unit's source and object
  from its work directory. The baseline is the longest prefix every unit of
  the set shares; a prefix keeps argument order, which decides include search
  and macro definitions.
- `private` is false: every module is visible to every set.
- `config-files` lists what the driver reads without being named: the clang
  `<driver>.cfg` of resolve_clang_driver unless the units pass
  `--no-default-config`, and GCC's `lib/gcc/<triple>/<version>/specs`
  (or the major version) beside the driver.

e2e 688 gains J (the decomposition, private, config-files) and K (the
discovered test's imports inside a comment and a raw string are not
`requires`); its F mapping compares paths with one separator, and the
fixture's main.cpp is well-formed. SPEC-005 R3.2a, R3.6, R3.8 and R3.9a state
the rules.

Refs #636

Author: speak-agent

.agents/docs/2026-09-14-636-build-database-and-the-latest-xlings.md

@@ -305,18 +305,31 @@ guarantee covers mcpp's writes. A build program that writes outside
 
 | S1 | from | note |
 |---|---|---|
-| toolchain id | `<compiler_name>-<version>-<targetTriple>` | |
+| toolchain id | `<compiler_family>-<version>-<triple>`, the triple as the compiler spells it | opaque to a consumer; `llvm`, as in `llvm@22.1.8` |
 | `family` | `Toolchain::compiler_name()` (`modules/toolchain-model/src/model.cppm:261-268`): `gcc`, `clang`, `msvc` | not `compiler_family()`, which answers `llvm` |
 | `driver`, `version`, `target`, `sysroot` | `binaryPath`, `version`, `targetTriple`, `sysroot` | |
 | `stdlib` | `name` and `version` from `stdlibId` and `stdlibVersion`; no `module-metadata` | std resolves through units (next row) |
+| `config-files` | clang: the `<driver>.cfg` of `resolve_clang_driver`, unless the units pass `--no-default-config`; GCC: `lib/gcc/<targetTriple>/<version or major>/specs` beside the driver | read from the layout the driver searches; no driver is run |
 | set `mcpp:std` | units for `stdModuleSource` and `stdCompatSource`, carrying the commands of 5.3 (3) | One rule for GCC's `bits/std.cc`, libc++'s `std.cppm`, MSVC's `std.ixx` and a package's own `std.cppm`; S1 §6.1 lets units outrank a manifest. `mcpp:` is the engine's reserved namespace (SPEC-002), so the name cannot collide with a package. |
 | sets | one per package; test targets' sources in `<package>:test` | `family-name` is the package; `ide.configuration` is `BuildContext::profile`; `ide.kind` comes from the package's declared targets |
 | `visible-sets` | every other set | The engine resolves imports over one flat graph per invocation (`scanner.cppm:1289-1319`). A narrower closure would describe a rule the build does not enforce; if the engine later refuses undeclared imports, the database inherits it. |
 | units | every `CompileUnit` except NASM units, as in the CDB (`compile_commands.cppm:225-228`) | rendered from the record of 5.3 (4) |
+| `baseline-arguments`, `local-arguments` | a unit's arguments are its driver, the set's baseline, its local arguments and its own `-c <source> -o <object>`; the baseline is the longest prefix every unit of the set shares | a prefix keeps argument order, which decides include search and macro definitions; a common subset would not |
+| `private` | `false` | every module is visible to every set, as the `visible-sets` row states |
 | `provides` | `providesModule` mapped to `""` | S1-8-6 permits an empty path for a producer that performs no build |
 | `requires` | `imports` | partitions are already written in full |
 | `ide.role` | the declaration form of 5.3 (5) | `unknown` for `scan_overrides` units |
 
+A target's entry source that no `sources` glob matched (a discovered test, a
+`main` outside the globs) had its imports read from line-leading `import` alone,
+so an import in a comment or a raw string was planned as one. Validating the
+lsp-mcpp repository's own database against S1 found it: its scanner test
+required three modules no source provides. The entry is now read by the
+scanner (`scan_entry_file`); a file the scanner refuses, which this path never
+refused, keeps its line-leading imports with the role `unknown`. The standard
+library check before planning reads entries the same way, so the two cannot
+disagree about `import std`.
+
 ### 5.5 `watch` and `inputs-fingerprint`
 
 - `watch` lists what the resolution read and a user edits: the manifests of the

docs/specs/build-database.md

@@ -6,7 +6,7 @@
 | 标题 | mcpp 输出的构建数据库:内容、取值规则与不写工程目录的保证 |
 | 状态 | 评审中 v1.0 |
 | 版本 | 1.0 |
-| 最后修改 | 2026-09-14 |
+| 最后修改 | 2026-09-15 |
 | 对应实现 | mcpp >= 2026.9.15.1 |
 | 相关设计文档 | `.agents/docs/2026-09-14-636-build-database-and-the-latest-xlings.md` |
 | 相关 issue | #636 |
@@ -71,6 +71,10 @@ mcpp 输出的 S1 文档满足 S1 等级 2,不输出 `ide.options`。等级 3 
   `target` 为编译器自身拼写的目标三元组;构建使用 sysroot 时给出 `sysroot`;`stdlib`
   给出 `name`(`libstdc++`、`libc++`、`msvc-stl` 或 `other`)与 `version`,不给出
   `module-metadata`,标准库模块经 §3.4 的单元解析。**已实现**
+- **R3.2a** `config-files` 列出驱动在命令行之外读取的配置文件,空数组表示没有:clang
+  驱动旁的 `<驱动名>.cfg`,单元带 `--no-default-config` 时不列出;GCC 驱动库目录中
+  `lib/gcc/<targetTriple>/<版本>/specs`,版本目录也可以只写主版本号。取值来自驱动
+  搜索的目录布局,命令不运行驱动。**已实现**
 
 ### 3.2 集合
 
@@ -82,7 +86,11 @@ mcpp 输出的 S1 文档满足 S1 等级 2,不输出 `ide.options`。等级 3 
 - **R3.5** `family-name` 为包名,`mcpp:std` 集合的为 `mcpp:std`;`ide.configuration`
   为 profile 名;`ide.kind` 在测试集合为 `test`,在根包集合按其目标为 `library`、
   `executable` 或 `other`,在依赖包集合与 `mcpp:std` 为 `library`。**已实现**
-- **R3.6** 不输出 `baseline-arguments` 与 `local-arguments`。**已实现**
+- **R3.6** 单元的 `arguments` 依次是驱动、集合的 `baseline-arguments`、单元的
+  `local-arguments`,以及单元自己结尾的 `-c <source> -o <object>`(若有;两个操作数
+  相对 `work-directory` 指向 `source` 与 `object`)。`baseline-arguments` 是集合中每个
+  单元去掉驱动与该结尾后的最长公共前缀。取前缀而不取公共子集,因为参数顺序决定
+  头文件搜索与宏定义。**已实现**
 
 ### 3.3 翻译单元
 
@@ -91,7 +99,7 @@ mcpp 输出的 S1 文档满足 S1 等级 2,不输出 `ide.options`。等级 3 
   `file`、`directory`、`arguments`、`output` 取自同一条记录,因而逐字相同。
   **已实现**
 - **R3.8** `provides` 把单元提供的模块名映射到空字符串,命令不执行构建(S1-8-6);
-  `requires` 为单元导入的模块名,分区写全名 `M:P`。不输出 `private`,即 `false`。
+  `requires` 为单元导入的模块名,分区写全名 `M:P`。`private` 为 `false`,理由同 R3.4。
   **已实现**
 - **R3.9** `ide.role` 取自扫描器读到的模块声明形式:
 
@@ -105,6 +113,11 @@ mcpp 输出的 S1 文档满足 S1 等级 2,不输出 `ide.options`。等级 3 
   | `scan_overrides` 声明的单元;P1689 扫描中无法区分实现单元与导入者的单元 | `unknown` |
 
   **已实现**
+- **R3.9a** 没有被 `sources` glob 匹配的目标入口源文件(发现的测试、glob 之外的
+  `main`)与包源文件由同一扫描器读取,注释与原始字符串中的 `import` 不是导入。扫描器
+  拒绝的入口文件(`#if` 块中的 `import`、头文件单元)从未在这条路径上被拒绝,现在也
+  不被拒绝:`requires` 为其代码中行首的 `import`,`ide.role` 为 `unknown`。入口声明
+  自身提供模块时,`ide.role` 为 `unknown`,因为构建不为该单元产出 BMI。**已实现**
 
 ### 3.4 标准库模块
 

src/build/build_database.cppm

@@ -35,6 +35,7 @@ import mcpp.modgraph.graph;
 import mcpp.modgraph.scanner;
 import mcpp.platform;
 import mcpp.toolchain.fingerprint;
+import mcpp.toolchain.linkmodel;
 import mcpp.toolchain.model;
 import mcpp.toolchain.stdmod;
 
@@ -151,23 +152,95 @@ Redirect redirect_kind(std::string_view w) {
     return j == w.size() ? Redirect::Detached : Redirect::Attached;
 }
 
-bool names_source(std::string_view word, const std::filesystem::path& source,
+bool names_path(std::string_view word, const std::filesystem::path& path,
                   const std::filesystem::path& cwd) {
     std::filesystem::path w{std::string(word)};
-    const auto want = source.lexically_normal();
+    const auto want = path.lexically_normal();
     if (w.lexically_normal() == want) return true;
     if (!w.is_absolute() && !cwd.empty() && (cwd / w).lexically_normal() == want)
         return true;
     return false;
 }
 
+// S1 `config-files`: the configuration files the driver reads without being
+// named on a command line. A clang driver reads the `.cfg` beside it unless a
+// unit passes `--no-default-config`, which mcpp does whenever that file exists
+// (mcpp.toolchain.linkmodel::resolve_clang_driver). A GCC driver reads the
+// `specs` file in its library directory for its own machine and version, which
+// a distribution may spell with the major version only. Found from the layout
+// the driver searches; no driver is run.
+nlohmann::json config_files(const mcpp::toolchain::Toolchain& tc,
+                            const std::vector<mcpp::build::UnitInvocation>& invocations) {
+    nlohmann::json out = nlohmann::json::array();
+    using C = mcpp::toolchain::CompilerId;
+    std::error_code ec;
+    if (tc.compiler == C::Clang) {
+        const auto dm = mcpp::toolchain::resolve_clang_driver(tc);
+        const bool read = std::ranges::any_of(invocations, [](auto const& inv) {
+            return std::ranges::find(inv.arguments, "--no-default-config") == inv.arguments.end();
+        });
+        if (dm.hasCfg && read) out.push_back(native_string(dm.cfgPath));
+    } else if (tc.compiler == C::GCC && !tc.targetTriple.empty()) {
+        const auto machine = tc.binaryPath.parent_path().parent_path()
+                           / "lib" / "gcc" / tc.targetTriple;
+        const auto major = tc.version.substr(0, tc.version.find('.'));
+        for (auto const& version : {tc.version, major}) {
+            const auto specs = machine / version / "specs";
+            if (!version.empty() && std::filesystem::is_regular_file(specs, ec)) {
+                out.push_back(native_string(specs));
+                break;
+            }
+        }
+    }
+    return out;
+}
+
+// S1 `baseline-arguments` and `local-arguments`. A unit's arguments are its
+// driver, then the set's baseline, then its local arguments, then its own
+// trailing `-c <source> -o <object>` when it has one: the baseline is the longest
+// prefix that every unit of the set shares after the driver and without that
+// tail. A prefix keeps the order of the arguments, which decides include search
+// and macro definitions; a common subset would not.
+void split_baseline(nlohmann::json& set) {
+    std::vector<std::vector<std::string>> semantic;
+    for (auto const& u : set["translation-units"]) {
+        auto args = u["arguments"].get<std::vector<std::string>>();
+        std::vector<std::string> rest(args.size() > 1 ? args.begin() + 1 : args.end(), args.end());
+        const std::filesystem::path cwd{u["work-directory"].get<std::string>()};
+        const auto n = rest.size();
+        if (n >= 4 && rest[n - 4] == "-c" && rest[n - 2] == "-o"
+            && names_path(rest[n - 3], u["source"].get<std::string>(), cwd)
+            && names_path(rest[n - 1], u["object"].get<std::string>(), cwd))
+            rest.resize(n - 4);
+        semantic.push_back(std::move(rest));
+    }
+    std::vector<std::string> baseline;
+    if (!semantic.empty()) {
+        baseline = semantic.front();
+        for (auto const& unit : semantic) {
+            std::size_t k = 0;
+            while (k < baseline.size() && k < unit.size() && baseline[k] == unit[k]) ++k;
+            baseline.resize(k);
+        }
+    }
+    std::size_t i = 0;
+    for (auto& u : set["translation-units"]) {
+        const auto& unit = semantic[i++];
+        u["local-arguments"] = std::vector<std::string>(
+            unit.begin() + static_cast<std::ptrdiff_t>(baseline.size()), unit.end());
+    }
+    set["baseline-arguments"] = std::move(baseline);
+}
+
 nlohmann::json toolchain_json(const mcpp::toolchain::Toolchain& tc,
-                              std::string_view compilerTriple) {
+                              std::string_view compilerTriple,
+                              const std::vector<mcpp::build::UnitInvocation>& invocations) {
     nlohmann::json j{
-        {"family",  std::string(tc.compiler_name())},
-        {"version", tc.version},
-        {"driver",  tc.binaryPath.string()},
-        {"target",  std::string(compilerTriple)},
+        {"family",       std::string(tc.compiler_name())},
+        {"version",      tc.version},
+        {"driver",       tc.binaryPath.string()},
+        {"target",       std::string(compilerTriple)},
+        {"config-files", config_files(tc, invocations)},
     };
     if (!tc.sysroot.empty()) j["sysroot"] = native_string(tc.sysroot);
     if (!tc.stdlibId.empty()) {
@@ -347,7 +420,7 @@ std::optional<Invocation> recover_invocation(const std::vector<std::string>& com
                 }
             }
             const bool named = std::ranges::any_of(argv, [&](const std::string& w) {
-                return names_source(w, source, cwd.empty() ? defaultDirectory : cwd);
+                return names_path(w, source, cwd.empty() ? defaultDirectory : cwd);
             });
             if (!named) continue;
             return Invocation{cwd.empty() ? defaultDirectory : cwd, std::move(argv)};
@@ -398,8 +471,6 @@ Rendered render(std::span<const Member> members,
         const std::string compilerTriple = ctx.plan.targetSide.llvmTriple.empty()
             ? ctx.tc.targetTriple : ctx.plan.targetSide.llvmTriple;
         const auto tcId = toolchain_id(ctx.tc, compilerTriple);
-        if (!toolchains.contains(tcId))
-            toolchains[tcId] = toolchain_json(ctx.tc, compilerTriple);
 
         const auto rootName = qualified_name(ctx.manifest);
         std::set<std::filesystem::path> testSources;
@@ -424,7 +495,10 @@ Rendered render(std::span<const Member> members,
         };
 
         const auto flags = mcpp::build::compute_flags(ctx.plan);
-        for (auto& inv : mcpp::build::unit_invocations(ctx.plan, flags)) {
+        auto invocations = mcpp::build::unit_invocations(ctx.plan, flags);
+        if (!toolchains.contains(tcId))
+            toolchains[tcId] = toolchain_json(ctx.tc, compilerTriple, invocations);
+        for (auto& inv : invocations) {
             const auto& cu = *inv.unit;
             const bool isTest = testSources.contains(cu.source.lexically_normal());
             const std::string package = cu.packageName.empty() ? rootName : cu.packageName;
@@ -448,6 +522,7 @@ Rendered render(std::span<const Member> members,
                 {"work-directory", std::move(inv.directory)},
                 {"arguments",      std::move(inv.arguments)},
                 {"object",         std::move(inv.output)},
+                {"private",        false},
                 {"provides",       std::move(provides)},
                 {"requires",       std::move(requires_)},
                 {"ide",            {{"role", std::string(role_name(cu.declaration))}}},
@@ -478,6 +553,7 @@ Rendered render(std::span<const Member> members,
                     {"work-directory", native_string(inv->workDirectory)},
                     {"arguments",      std::move(inv->arguments)},
                     {"object",         native_string(object)},
+                    {"private",        false},
                     {"provides",       {{std::string(module), ""}}},
                     {"requires",       std::move(requires_)},
                     {"ide",            {{"role", "module-interface"}}},
@@ -493,7 +569,7 @@ Rendered render(std::span<const Member> members,
             nlohmann::json visible = nlohmann::json::array();
             for (auto const& other : order)
                 if (other != name) visible.push_back(other);
-            sets.push_back(nlohmann::json{
+            nlohmann::json setJson{
                 {"name",              name},
                 {"family-name",       set.familyName},
                 {"visible-sets",      std::move(visible)},
@@ -503,7 +579,9 @@ Rendered render(std::span<const Member> members,
                     {"configuration", ctx.profile},
                     {"kind",          set.kind},
                 }},
-            });
+            };
+            split_baseline(setJson);
+            sets.push_back(std::move(setJson));
         }
 
         watch_file(ctx.projectRoot / "mcpp.lock");