fix(scan): an entry source outside the globs is read by the scanner

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, in make_plan and again in the standard library check before planning.
An import inside a comment or a raw string was therefore planned as one.
Validating the lsp-mcpp repository's own build database against S1 found
it: its scanner test was planned as importing three modules no source
provides.

scan_entry_file reads such a file with scan_file. The scanner's refusals (an
import inside `#if`, a header unit, an extension without a role) were never
applied on this path and are not applied now: a file it refuses yields the
line-leading imports of its code, comments and raw strings removed, with the
declaration form Unknown. Both readers now call it, so they cannot disagree
about `import std`.

Refs #636

Author: speak-agent

src/build/plan.cppm

@@ -1919,28 +1919,16 @@ make_plan(const mcpp::manifest::Manifest&         manifest,
             mcpp::modgraph::normalize_include_flags(projectRoot, main_cu.packageCflags);
             mcpp::modgraph::normalize_include_flags(projectRoot, main_cu.packageCxxflags);
 
-            // We didn't scan main.cpp earlier (it's not in scanner output unless globbed in).
-            // Best-effort: scan its imports here.
-            std::ifstream is(*lu.entryMain);
-            std::string line;
-            while (std::getline(is, line)) {
-                auto trim = [](std::string s) {
-                    while (!s.empty() && std::isspace(static_cast<unsigned char>(s.front()))) s.erase(0, 1);
-                    while (!s.empty() && std::isspace(static_cast<unsigned char>(s.back())))  s.pop_back();
-                    return s;
-                };
-                line = trim(line);
-                if (line.starts_with("import ")) {
-                    std::string name;
-                    std::size_t i = 7;
-                    while (i < line.size() && (std::isalnum(static_cast<unsigned char>(line[i]))
-                                               || line[i] == '_' || line[i] == '.')) {
-                        name.push_back(line[i]);
-                        ++i;
-                    }
-                    if (!name.empty()) main_cu.imports.push_back(name);
-                }
-            }
+            // The entry is in the package scan only when a `sources` glob
+            // matched it; otherwise it is scanned here. The unit is built as one
+            // that provides nothing, so a declaration the scanner reads as
+            // providing a module is recorded as undecided rather than as a
+            // role the plan does not build.
+            const auto entry = mcpp::modgraph::scan_entry_file(
+                *lu.entryMain, main_cu.packageName, rootExtTable);
+            for (auto const& req : entry.requires_) main_cu.imports.push_back(req.logicalName);
+            main_cu.declaration = entry.provides ? mcpp::modgraph::ModuleDeclaration::Unknown
+                                                 : entry.declaration;
 
             // mcpp#240: the entry main may ALSO have been scanned (globbed into
             // [modules].sources — the near-universal `src/**/*.cpp`). When it

src/build/prepare.cppm

@@ -648,43 +648,6 @@ bool is_std_module(std::string_view name) {
     return name == "std" || name == "std.compat";
 }
 
-std::string trim_copy(std::string s) {
-    while (!s.empty() && std::isspace(static_cast<unsigned char>(s.front())))
-        s.erase(0, 1);
-    while (!s.empty() && std::isspace(static_cast<unsigned char>(s.back())))
-        s.pop_back();
-    return s;
-}
-
-bool source_file_imports_std(const std::filesystem::path& path) {
-    std::ifstream is(path);
-    if (!is) return false;
-
-    std::string line;
-    while (std::getline(is, line)) {
-        line = trim_copy(std::move(line));
-        std::size_t i = std::string::npos;
-        if (line.starts_with("import ")) {
-            i = 7;
-        } else if (line.starts_with("export import ")) {
-            i = 14;
-        }
-        if (i == std::string::npos) continue;
-        while (i < line.size() && std::isspace(static_cast<unsigned char>(line[i])))
-            ++i;
-
-        std::string name;
-        while (i < line.size()
-            && (std::isalnum(static_cast<unsigned char>(line[i]))
-                || line[i] == '_' || line[i] == '.' || line[i] == ':')) {
-            name.push_back(line[i]);
-            ++i;
-        }
-        if (is_std_module(name)) return true;
-    }
-    return false;
-}
-
 bool graph_or_targets_import_std(const mcpp::modgraph::Graph& graph,
                                  const mcpp::manifest::Manifest& manifest,
                                  const std::filesystem::path& projectRoot) {
@@ -696,10 +659,16 @@ bool graph_or_targets_import_std(const mcpp::modgraph::Graph& graph,
     }
 
     // Some target entry files can be added to the plan after the package scan.
-    // Check them here so std BMI setup matches what make_plan will compile.
+    // Check them here so std BMI setup matches what make_plan will compile: they
+    // are read by the same scan_entry_file make_plan reads them with.
+    const auto extTable = mcpp::extension_table_for(manifest.buildConfig.moduleExtensions,
+                                                    manifest.buildConfig.deviceExtensions);
     for (auto& t : manifest.targets) {
-        if (!t.main.empty() && source_file_imports_std(projectRoot / t.main))
-            return true;
+        if (t.main.empty()) continue;
+        const auto entry = mcpp::modgraph::scan_entry_file(projectRoot / t.main,
+                                                           manifest.package.name, extTable);
+        for (auto const& req : entry.requires_)
+            if (is_std_module(req.logicalName)) return true;
     }
     return false;
 }

src/modgraph/scanner.cppm

@@ -63,6 +63,16 @@ std::expected<SourceUnit, ScanError> scan_file(const std::filesystem::path& file
                                                const std::string&           packageName,
                                                const mcpp::ExtensionTable&  extTable);
 
+// Scan the entry source of a target that no `sources` glob matched: a
+// discovered test, or a `main` outside the globs. The unit is scan_file's when
+// scan_file accepts the file. Its refusals (an import inside `#if`, a header
+// unit, an extension without a role) were never applied to such a file and are
+// not applied here: a file it refuses yields the line-leading imports of its
+// code, with comments and raw strings removed, and the declaration form Unknown.
+SourceUnit scan_entry_file(const std::filesystem::path& file,
+                           const std::string&           packageName,
+                           const mcpp::ExtensionTable&  extTable);
+
 // Scan the entire package: collects all sources via manifest globs and returns a Graph.
 struct ScanResult {
     Graph                       graph;
@@ -1005,6 +1015,34 @@ std::expected<SourceUnit, ScanError> scan_file(const std::filesystem::path& file
     return u;
 }
 
+SourceUnit scan_entry_file(const std::filesystem::path& file,
+                           const std::string&           packageName,
+                           const mcpp::ExtensionTable&  extTable)
+{
+    if (auto scanned = scan_file(file, packageName, extTable)) return std::move(*scanned);
+
+    SourceUnit u;
+    u.path        = file;
+    u.packageName = packageName;
+    u.kind        = mcpp::classify(file, extTable);
+    u.declaration = ModuleDeclaration::Unknown;
+    std::ifstream is(file);
+    bool in_raw = false, in_block = false;
+    std::string raw_close, line;
+    while (std::getline(is, line)) {
+        const std::string code = strip_noncode(line, in_block, in_raw, raw_close);
+        std::string_view r = trim(code);
+        if (r.starts_with("export ") || r.starts_with("export\t")) r = trim(r.substr(6));
+        if (!r.starts_with("import ") && !r.starts_with("import\t")) continue;
+        r = trim(r.substr(6));
+        std::string name;
+        for (std::size_t i = 0; i < r.size() && is_module_name_char(r[i]); ++i)
+            name.push_back(r[i]);
+        if (!name.empty() && name.front() != ':') u.requires_.push_back(ModuleId{name});
+    }
+    return u;
+}
+
 namespace {
 
 std::vector<std::filesystem::path>

tests/unit/test_modgraph.cpp

@@ -128,6 +128,50 @@ TEST(Scanner, DeclarationFormIsRecordedAsRead) {
     std::filesystem::remove_all(dir);
 }
 
+// ─── an entry source no `sources` glob matched ─────────────────────────────
+//
+// A discovered test, or a `main` outside the globs, is not in the package scan.
+// Its imports were read from line-leading `import` alone, so an import inside a
+// comment or a raw string was recorded as one: a scanner test in lsp-mcpp was
+// planned as importing three modules no source provides.
+TEST(Scanner, AnEntrySourceIsReadByTheScanner) {
+    auto dir = make_tempdir("scan-entry");
+    write(dir / "t.cpp",
+          "import std;\n"
+          "/* a comment\n"
+          "   import in.comment; */\n"
+          "auto s = R\"x(\n"
+          "import in.raw;\n"
+          ")x\";\n"
+          "import real;\n"
+          "int main() {}\n");
+    auto u = scan_entry_file(dir / "t.cpp", "pkg", mcpp::builtin_extension_table());
+    std::vector<std::string> names;
+    for (auto const& r : u.requires_) names.push_back(r.logicalName);
+    EXPECT_EQ(names, (std::vector<std::string>{"std", "real"}));
+    EXPECT_EQ(static_cast<int>(u.declaration), static_cast<int>(ModuleDeclaration::None));
+    std::filesystem::remove_all(dir);
+}
+
+// The scanner's refusals were never applied to such a file, and are not now: a
+// file it refuses keeps its line-leading imports, and its form is not decided.
+TEST(Scanner, AnEntrySourceTheScannerRefusesKeepsItsImports) {
+    auto dir = make_tempdir("scan-entry-refused");
+    write(dir / "t.cpp",
+          "#ifdef WITH_EXTRA\n"
+          "import extra;\n"
+          "#endif\n"
+          "export import std;\n"
+          "int main() {}\n");
+    ASSERT_FALSE(scan_file(dir / "t.cpp", "pkg", mcpp::builtin_extension_table()).has_value());
+    auto u = scan_entry_file(dir / "t.cpp", "pkg", mcpp::builtin_extension_table());
+    std::vector<std::string> names;
+    for (auto const& r : u.requires_) names.push_back(r.logicalName);
+    EXPECT_EQ(names, (std::vector<std::string>{"extra", "std"}));
+    EXPECT_EQ(static_cast<int>(u.declaration), static_cast<int>(ModuleDeclaration::Unknown));
+    std::filesystem::remove_all(dir);
+}
+
 TEST(Scanner, PlainImplementationUnitStillRequiresItsInterface) {
     auto dir = make_tempdir("scan-implunit");
     std::filesystem::create_directories(dir / "src");