feat(toolchain): native MSVC cl.exe build backend (C1-C7)

- C1 env model: find_windows_sdk() + build_env_for_cl() synthesize
  INCLUDE/LIB/PATH/VSLANG=1033 from the detected VC tools + SDK (no
  vcvarsall run); enrich_toolchain_from_cl fills tc.envOverrides; missing
  SDK keeps detection working and fails the BUILD with guidance (replaces
  the 0.0.88 'not yet supported' gate — the gate is gone).
- C2 emission: SeparateLinker rules (link.exe /OUT + rspfile — cmd's 8191
  limit), lib.exe archives, /DLL+/IMPLIB shared, deps=msvc via
  /showIncludes, /interface /TP for .cppm module units, /std: mapping
  (std_flag_for), /MD|/MT CRT model, /Od, /nologo /EHsc /utf-8 baseline,
  .obj object extension end to end (plan objExt + std staging names).
- C3 std/std.compat staging: single-cl commands (/ifcOutput), ifc.cache
  layout, registry-dispatched staged paths (clang hardcoding removed),
  stdmod executes with the toolchain env (capture_with_env).
- C4 scanning: /scanDependencies as the third builtin P1689 producer
  (provider capability + ninja scan rule); dyndep ifc-parameterized as-is.
- C8 fast path: '@env' multi-var encoding in the build cache env slot so
  incremental msvc builds re-create INCLUDE/LIB for ninja.
- cd /d in std stage commands (cmd.exe won't change drive without it;
  D: workspace + C: BMI cache is the real CI layout).

Zero-diff gate re-verified for GCC and LLVM vs the 0.0.89 release binary.

Author: Sunrisepeak

src/build/execute.cppm

@@ -335,8 +335,22 @@ export std::optional<int> try_fast_build(const std::filesystem::path& projectRoo
     if (verbose) argv.push_back("-v");
 
     std::vector<std::pair<std::string, std::string>> childEnv;
-    if (runtimeEnvKey != "-" && !runtimeEnvValue.empty())
+    if (runtimeEnvKey == "@env") {
+        // Multi-var encoding (MSVC INCLUDE/LIB/PATH/VSLANG + optional runtime
+        // pair): \x1f-separated k=v records in the single value slot.
+        std::string_view rest = runtimeEnvValue;
+        while (!rest.empty()) {
+            auto sep = rest.find('\x1f');
+            auto rec = rest.substr(0, sep);
+            if (auto eq = rec.find('='); eq != std::string_view::npos && eq > 0)
+                childEnv.emplace_back(std::string(rec.substr(0, eq)),
+                                      std::string(rec.substr(eq + 1)));
+            if (sep == std::string_view::npos) break;
+            rest.remove_prefix(sep + 1);
+        }
+    } else if (runtimeEnvKey != "-" && !runtimeEnvValue.empty()) {
         childEnv.emplace_back(runtimeEnvKey, runtimeEnvValue);
+    }
 
     auto t0 = std::chrono::steady_clock::now();
     // capture_exec merges stderr into the captured output (replacing `2>&1`),

src/build/flags.cppm

@@ -27,9 +27,10 @@ struct CompileFlags {
     std::string cxx;                  // full cxxflags string
     std::string cc;                   // full cflags string
     std::string ld;                   // ldflags string
-    std::filesystem::path cxxBinary;  // g++ / clang++
-    std::filesystem::path ccBinary;   // gcc / clang (derived)
-    std::filesystem::path arBinary;   // ar path (may be empty → use PATH)
+    std::filesystem::path cxxBinary;  // g++ / clang++ / cl.exe
+    std::filesystem::path ccBinary;   // gcc / clang (derived; cl.exe = same)
+    std::filesystem::path arBinary;   // ar / llvm-ar / lib.exe (empty → PATH)
+    std::filesystem::path ldBinary;   // link.exe (SeparateLinker dialects only)
     std::string sysroot;              // --sysroot=... (for ninja ldflags)
     std::string bFlag;                // -B<binutils> (for ninja ldflags)
     bool staticStdlib = true;
@@ -142,15 +143,17 @@ CompileFlags compute_flags(const BuildPlan& plan) {
     f.cxxBinary = plan.toolchain.binaryPath;
     f.ccBinary = mcpp::toolchain::derive_c_compiler(plan.toolchain);
 
-    // PIC?
+    const bool isMsvcDialect = (d.id == "msvc");
+
+    // PIC? (GNU-only concept; PE code is position independent by design.)
     bool need_pic = false;
     for (auto& lu : plan.linkUnits) {
         if (lu.kind == LinkUnit::SharedLibrary) {
             need_pic = true;
             break;
         }
     }
-    std::string pic_flag = need_pic ? " -fPIC" : "";
+    std::string pic_flag = (need_pic && !isMsvcDialect) ? " -fPIC" : "";
 
     // Include dirs
     std::string include_flags;
@@ -235,9 +238,21 @@ CompileFlags compute_flags(const BuildPlan& plan) {
     // unless the profile pins -O0.
     auto& prof = plan.manifest.buildConfig;
     std::string opt_flag = isMuslTc && prof.optLevel != "0"
-        ? " -Og" : std::format(" {}{}", d.optPrefix, prof.optLevel);
+        ? " -Og"
+        : (isMsvcDialect && prof.optLevel == "0")
+        ? " /Od"    // MSVC's no-opt spelling (there is no /O0)
+        : std::format(" {}{}", d.optPrefix, prof.optLevel);
     if (prof.debug) opt_flag += std::format(" {}", d.debugFlags);
-    if (prof.lto)   opt_flag += " -flto";
+    if (prof.lto && !isMsvcDialect) opt_flag += " -flto";
+
+    // MSVC baseline: /nologo /EHsc /utf-8 (dialect alwaysFlags) + the CRT
+    // model — /MD default, /MT under static linkage (portable-by-default is
+    // impossible on MSVC-ABI; /MT at least removes the vcruntime DLL dep).
+    std::string msvc_base;
+    if (isMsvcDialect) {
+        msvc_base = std::format(" {}", d.alwaysFlags);
+        msvc_base += (plan.manifest.buildConfig.linkage == "static") ? " /MT" : " /MD";
+    }
 
     // User link flags
     std::string user_ldflags;
@@ -264,9 +279,8 @@ CompileFlags compute_flags(const BuildPlan& plan) {
     }
     std::string std_compat_module_flag;
     if (!traits.stdCompatBmiUsePrefix.empty() && !plan.stdCompatBmiPath.empty()) {
-        // NOTE: staging path is Clang's today; registry-dispatch when the
-        // MSVC backend lands (std.compat.ixx staging).
-        auto compatDst = mcpp::toolchain::clang::staged_std_compat_bmi_path(plan.outputDir);
+        auto compatDst = mcpp::toolchain::staged_std_compat_bmi_path(
+            plan.toolchain, plan.outputDir);
         std_compat_module_flag = std::string(traits.stdCompatBmiUsePrefix)
                                + escape_path(compatDst);
     }
@@ -290,12 +304,17 @@ CompileFlags compute_flags(const BuildPlan& plan) {
     // plan.dialectFlags rides right behind -std= (issue #210): module-graph-
     // global dialect flags reach every TU (deps included) via this global
     // cxxflags string, exactly like the standard flag itself.
-    f.cxx = std::format("{}{}{}{}{}{}{}{}{}{}{}", cxx_std_flag, plan.dialectFlags,
-                        module_flag, std_module_flag,
+    f.cxx = std::format("{}{}{}{}{}{}{}{}{}{}{}{}", cxx_std_flag, plan.dialectFlags,
+                        msvc_base, module_flag, std_module_flag,
                         std_compat_module_flag, prebuilt_module_flag,
                         opt_flag, pic_flag, compile_toolchain_flags, b_flag, include_flags);
-    f.cc = std::format("{}{}{}{}{}{}{}", d.stdPrefix, c_std, opt_flag, pic_flag,
-                       compile_toolchain_flags, b_flag, include_flags);
+    // MSVC compiles C with cl.exe too; /std: for C uses cN spellings — skip
+    // the C standard flag there (cl defaults are fine for the C entry TUs).
+    f.cc = isMsvcDialect
+        ? std::format("{}{}{}{}{}", msvc_base, opt_flag, compile_toolchain_flags,
+                      b_flag, include_flags)
+        : std::format("{}{}{}{}{}{}{}", d.stdPrefix, c_std, opt_flag, pic_flag,
+                      compile_toolchain_flags, b_flag, include_flags);
 
     // Link flags
     f.staticStdlib = plan.manifest.buildConfig.staticStdlib;
@@ -343,6 +362,18 @@ CompileFlags compute_flags(const BuildPlan& plan) {
     if (prof.strip) link_extra += " -s";
 
     if constexpr (mcpp::platform::is_windows) {
+        if (isMsvcDialect) {
+            // Native cl.exe: link.exe does the link (SeparateLinker). Search
+            // paths for dependency runtime import libs via /LIBPATH; user
+            // ldflags pass through verbatim; GNU link_extra (-flto/-s) does
+            // not apply.
+            f.ldBinary = mcpp::toolchain::link_tool(plan.toolchain);
+            std::string libpaths;
+            for (auto& dir : plan.depRuntimeLibraryDirs)
+                libpaths += " /LIBPATH:" + escape_path(dir);
+            f.ld = libpaths + user_ldflags;
+            return f;
+        }
         // PE link: no rpath/loader/payload model. MSVC-ABI Clang needs
         // nothing extra (MSVC STL/SDK via the driver); MinGW adds the static
         // libstdc++/libgcc pair (static_stdlib above) and -B so its own

src/build/ninja_backend.cppm

@@ -297,6 +297,14 @@ std::string emit_ninja_string(const BuildPlan& plan) {
     } else {
         append("ar        = ar\n");
     }
+    // Separate linker (link.exe) for the msvc dialect.
+    const bool separateLinker =
+        dial.linkStyle == mcpp::toolchain::CommandDialect::LinkStyle::SeparateLinker;
+    if (separateLinker) {
+        append(std::format("ld        = {}\n",
+            flags.ldBinary.empty() ? std::string("link.exe")
+                                   : escape_ninja_path(flags.ldBinary)));
+    }
     if (dyndep) {
         append(std::format("mcpp      = {}\n", escape_ninja_path(mcpp_exe_path())));
         if (!plan.scanDepsPath.empty()) {
@@ -339,14 +347,25 @@ std::string emit_ninja_string(const BuildPlan& plan) {
     // msvc); the rule *structure* is shared across compilers.
     std::string module_output_flag = traits.needsExplicitModuleOutput
         ? std::string(traits.moduleOutputPrefix) + "$bmi_out" : "";
+    // msvc: /showIncludes feeds ninja's deps=msvc header tracking; the
+    // stable-English prefix is guaranteed by VSLANG=1033 in envOverrides.
+    const bool msvcDeps = dial.ninjaDepsMode == std::string_view("msvc");
     const std::string compile_tail = std::format(
-        "{} $in {}$out", dial.compileOnly, dial.outputObjPrefix);
+        "{}{} $in {}$out",
+        msvcDeps ? "/showIncludes " : "", dial.compileOnly, dial.outputObjPrefix);
+    auto append_deps = [&] {
+        if (msvcDeps) append("  deps = msvc\n");
+    };
+    // cl.exe needs /TP (our module interfaces are .cppm, unknown to cl) and
+    // /interface to treat the TU as a module interface unit.
+    const std::string module_src_flags = msvcDeps ? " /interface /TP" : "";
     append("rule cxx_module\n");
     if constexpr (mcpp::platform::is_windows) {
         // Windows: skip BMI restat optimization (requires POSIX shell).
         append(std::format("  command = "
-               "$cxx $local_includes $cxxflags $unit_cxxflags{} {}\n",
-               module_output_flag, compile_tail));
+               "$cxx $local_includes $cxxflags $unit_cxxflags{}{} {}\n",
+               module_output_flag, module_src_flags, compile_tail));
+        append_deps();
     } else {
         append(std::format("  command = "
                "if [ -n \"$bmi_out\" ] && [ -f \"$bmi_out\" ]; then "
@@ -370,6 +389,7 @@ std::string emit_ninja_string(const BuildPlan& plan) {
         "  command = $cxx $local_includes $cxxflags $unit_cxxflags {}\n",
         compile_tail));
     append("  description = OBJ $out\n");
+    append_deps();
     if (dyndep)
         append("  restat = 1\n");
     append("\n");
@@ -380,25 +400,47 @@ std::string emit_ninja_string(const BuildPlan& plan) {
             "  command = $cc $local_includes $cflags $unit_cflags {}\n",
             compile_tail));
         append("  description = CC $out\n");
+        append_deps();
         if (dyndep)
             append("  restat = 1\n");
         append("\n");
     }
 
-    // Link rule: driver-style today (g++/clang++ act as the linker). The
-    // dialect's LinkStyle::SeparateLinker (link.exe /OUT: + rspfile) is the
-    // MSVC backend's insertion point — unreachable until that lands.
-    append("rule cxx_link\n");
-    append("  command = $cxx $in -o $out $ldflags $unit_ldflags\n");
-    append("  description = LINK $out\n\n");
+    // Link/archive/shared: driver-style (g++/clang++ are the linker) vs the
+    // msvc dialect's separate link.exe/lib.exe. The msvc commands go through
+    // response files — object lists exceed cmd.exe's 8191-char limit fast.
+    if (separateLinker) {
+        append("rule cxx_link\n");
+        append("  command = $ld /nologo /OUT:$out @$out.rsp $ldflags $unit_ldflags\n");
+        append("  rspfile = $out.rsp\n");
+        append("  rspfile_content = $in\n");
+        append("  description = LINK $out\n\n");
+
+        append("rule cxx_archive\n");
+        append("  command = $ar /nologo /OUT:$out @$out.rsp\n");
+        append("  rspfile = $out.rsp\n");
+        append("  rspfile_content = $in\n");
+        append("  description = AR $out\n\n");
+
+        append("rule cxx_shared\n");
+        append("  command = $ld /nologo /DLL /OUT:$out /IMPLIB:$out.lib "
+               "@$out.rsp $ldflags $unit_ldflags\n");
+        append("  rspfile = $out.rsp\n");
+        append("  rspfile_content = $in\n");
+        append("  description = SHARED $out\n\n");
+    } else {
+        append("rule cxx_link\n");
+        append("  command = $cxx $in -o $out $ldflags $unit_ldflags\n");
+        append("  description = LINK $out\n\n");
 
-    append("rule cxx_archive\n");
-    append(std::format("  command = {}\n", dial.archiveCmd));
-    append("  description = AR $out\n\n");
+        append("rule cxx_archive\n");
+        append(std::format("  command = {}\n", dial.archiveCmd));
+        append("  description = AR $out\n\n");
 
-    append("rule cxx_shared\n");
-    append("  command = $cxx -shared $in -o $out $ldflags $soname_flag $unit_ldflags\n");
-    append("  description = SHARED $out\n\n");
+        append("rule cxx_shared\n");
+        append("  command = $cxx -shared $in -o $out $ldflags $soname_flag $unit_ldflags\n");
+        append("  description = SHARED $out\n\n");
+    }
 
     append("rule runtime_alias\n");
     if constexpr (mcpp::platform::is_windows) {
@@ -413,7 +455,12 @@ std::string emit_ninja_string(const BuildPlan& plan) {
         // GCC: built-in -fdeps-format=p1689r5 flags during preprocessing.
         // Clang: external clang-scan-deps tool with -format=p1689.
         append("rule cxx_scan\n");
-        if (plan.scanDepsPath.empty()) {
+        if (msvcDeps) {
+            // MSVC: compiler-integrated P1689 via /scanDependencies (scan
+            // only — no codegen); /TP because our module units are .cppm.
+            append("  command = $cxx $local_includes $cxxflags $unit_cxxflags "
+                   "/scanDependencies $out /TP /c $in /Fo:$compile_target\n");
+        } else if (plan.scanDepsPath.empty()) {
             // GCC path: compiler-integrated P1689 scanning.
             append("  command = $cxx $local_includes $cxxflags -fmodules "
                    "$unit_cxxflags "
@@ -445,7 +492,8 @@ std::string emit_ninja_string(const BuildPlan& plan) {
 
     // Stage prebuilt std artifacts into the compiler-specific BMI cache.
     auto std_bmi_dst = mcpp::toolchain::staged_std_bmi_path(plan.toolchain, {});
-    auto std_o_dst = std::filesystem::path("obj") / "std.o";
+    auto std_o_dst = std::filesystem::path("obj")
+                   / std::format("std{}", dial.objExt);
 
     bool has_std_artifacts = !plan.stdBmiPath.empty() && !plan.stdObjectPath.empty();
     if (has_std_artifacts) {
@@ -456,8 +504,10 @@ std::string emit_ninja_string(const BuildPlan& plan) {
     }
 
     bool has_std_compat = !plan.stdCompatBmiPath.empty() && !plan.stdCompatObjectPath.empty();
-    auto compat_bmi_dst = std::filesystem::path("pcm.cache") / "std.compat.pcm";
-    auto compat_o_dst = std::filesystem::path("obj") / "std.compat.o";
+    auto compat_bmi_dst = std::filesystem::path(traits.bmiDir)
+                        / std::format("std.compat{}", traits.bmiExt);
+    auto compat_o_dst = std::filesystem::path("obj")
+                      / std::format("std.compat{}", dial.objExt);
     if (has_std_compat) {
         // std.compat.pcm depends on std.pcm — ensure std.pcm is staged first
         // so clang can resolve the transitive dependency when loading std.compat.pcm.
@@ -803,7 +853,22 @@ std::expected<BuildResult, BuildError> NinjaBackend::build(const BuildPlan& plan
     // Record ninja binary for P0 fast-path cache.
     BuildResult r;
     r.ninjaProgram = ninjaProgram;
-    if (auto runtimeEnv = runtime_env_for_dirs(plan.toolchain.compilerRuntimeDirs)) {
+    if (!plan.toolchain.envOverrides.empty()) {
+        // Toolchain-declared env (MSVC INCLUDE/LIB/PATH/VSLANG). Encode all
+        // pairs (plus any runtime-dirs pair) into the fast-path cache's
+        // single env slot: "@env" key + \x1f-separated k=v records — the
+        // fast path must re-create this exact environment for ninja.
+        r.runtimeEnvKey = "@env";
+        std::string joined;
+        auto add = [&](const std::string& k, const std::string& v) {
+            if (!joined.empty()) joined += '\x1f';
+            joined += k; joined += '='; joined += v;
+        };
+        if (auto runtimeEnv = runtime_env_for_dirs(plan.toolchain.compilerRuntimeDirs))
+            add(runtimeEnv->first, runtimeEnv->second);
+        for (auto& ev : plan.toolchain.envOverrides) add(ev.key, ev.value);
+        r.runtimeEnvValue = std::move(joined);
+    } else if (auto runtimeEnv = runtime_env_for_dirs(plan.toolchain.compilerRuntimeDirs)) {
         r.runtimeEnvKey = runtimeEnv->first;
         r.runtimeEnvValue = runtimeEnv->second;
     } else {
@@ -824,12 +889,11 @@ std::expected<BuildResult, BuildError> NinjaBackend::build(const BuildPlan& plan
     if (opts.parallelJobs)
         nargv.push_back(std::format("-j{}", opts.parallelJobs));
 
+    // Real env pairs for THIS run (the "@env" cache encoding above is only
+    // for the fast path's later re-creation of the same environment).
     std::vector<std::pair<std::string, std::string>> nenv;
-    if (r.runtimeEnvKey != "-" && !r.runtimeEnvValue.empty())
-        nenv.emplace_back(r.runtimeEnvKey, r.runtimeEnvValue);
-    // Toolchain-declared env (empty for GCC/Clang; MSVC's INCLUDE/LIB/PATH).
-    // NOTE: not persisted in the fast-path cache yet — revisit when the MSVC
-    // backend lands (its fast path must re-derive these from detection).
+    if (auto runtimeEnv = runtime_env_for_dirs(plan.toolchain.compilerRuntimeDirs))
+        nenv.emplace_back(runtimeEnv->first, runtimeEnv->second);
     for (auto& ev : plan.toolchain.envOverrides)
         nenv.emplace_back(ev.key, ev.value);
 

src/build/plan.cppm

@@ -130,10 +130,13 @@ std::string sanitize_for_path(std::string_view module_name) {
     return s;
 }
 
-std::string object_filename_for(const std::filesystem::path& src) {
+std::string object_filename_for(const std::filesystem::path& src,
+                                std::string_view objExt = ".o") {
     auto stem = src.stem().string();
     // distinguish .cppm vs .cpp by extension prefix to avoid collisions
-    return stem + (src.extension() == ".cppm" ? ".m.o" : ".o");
+    return stem + (src.extension() == ".cppm"
+                       ? ".m" + std::string(objExt)
+                       : std::string(objExt));
 }
 
 std::string qualified_package_name(const mcpp::manifest::Manifest& manifest) {
@@ -326,6 +329,8 @@ BuildPlan make_plan(const mcpp::manifest::Manifest&         manifest,
         plan.dialectFlags += ' ';
         plan.dialectFlags += f;
     }
+    // Object extension is dialect-spelled (.o vs .obj).
+    const std::string_view objExt = mcpp::toolchain::dialect_for(tc).objExt;
     plan.projectRoot     = projectRoot;
     plan.outputDir       = outputDir;
     plan.stdBmiPath     = stdBmiPath;
@@ -400,7 +405,7 @@ BuildPlan make_plan(const mcpp::manifest::Manifest&         manifest,
     //     derived from `<pkg>/<parent-dir>` so collisions are impossible.
     std::map<std::string, int> basenameCount;
     for (auto idx : topoOrder) {
-        basenameCount[object_filename_for(graph.units[idx].path)]++;
+        basenameCount[object_filename_for(graph.units[idx].path, objExt)]++;
     }
     auto sanitize = [](const std::string& s) {
         std::string out; out.reserve(s.size());
@@ -417,7 +422,7 @@ BuildPlan make_plan(const mcpp::manifest::Manifest&         manifest,
         cu.localIncludeDirs = u.localIncludeDirs;
         cu.packageCflags = u.packageCflags;
         cu.packageCxxflags = u.packageCxxflags;
-        const auto fname = object_filename_for(u.path);
+        const auto fname = object_filename_for(u.path, objExt);
         if (basenameCount[fname] > 1) {
             // Use <sanitized-pkg>/<parent-dir-name> as prefix to handle
             // both cross-package (multi-version mangling) and intra-package
@@ -661,7 +666,7 @@ BuildPlan make_plan(const mcpp::manifest::Manifest&         manifest,
             // Add main.cpp -> obj/main.o
             CompileUnit main_cu;
             main_cu.source = *lu.entryMain;
-            main_cu.object = std::filesystem::path("obj") / object_filename_for(*lu.entryMain);
+            main_cu.object = std::filesystem::path("obj") / object_filename_for(*lu.entryMain, objExt);
             main_cu.packageName = qualified_package_name(manifest);
             if (!packages.empty() && packages[0].usageResolved) {
                 main_cu.localIncludeDirs = packages[0].privateBuild.includeDirs;