|
| 1 | +// mcpp.toolchain.cppfly — the `standard = "c++fly"` capability: per-compiler |
| 2 | +// support & mapping for "latest -std= level + every enableable experimental |
| 3 | +// gate (language + stdlib)". Pure data tables + query functions, the fourth |
| 4 | +// sibling of CommandDialect / BmiTraits / ProviderCapabilities — and the |
| 5 | +// first consumer of Toolchain::version for gating. |
| 6 | +// |
| 7 | +// Also owns the "latest level for this toolchain" table, which fixes |
| 8 | +// standard = "c++latest" reaching the GNU driver as the invalid spelling |
| 9 | +// -std=c++latest (design §11-Q5). |
| 10 | +// |
| 11 | +// Table facts pinned by on-machine probes (gcc 16.1.0, 2026-07-14): |
| 12 | +// contracts are enabled by -std=c++26 alone (__cpp_contracts defined); |
| 13 | +// reflection additionally needs -freflection (__cpp_impl_reflection). |
| 14 | +// See .agents/docs/2026-07-14-std-features-experimental-gate-design.md. |
| 15 | + |
| 16 | +export module mcpp.toolchain.cppfly; |
| 17 | + |
| 18 | +import std; |
| 19 | +import mcpp.toolchain.dialect; |
| 20 | +import mcpp.toolchain.model; |
| 21 | + |
| 22 | +export namespace mcpp::toolchain::cppfly { |
| 23 | + |
| 24 | +struct FeatureState { |
| 25 | + std::string name; // "reflection" |
| 26 | + std::string paper; // "P2996" — summary/diagnostics |
| 27 | + std::string flags; // enabled: extra flags ("" = enabled by std level alone) |
| 28 | + std::string reason; // skipped: why |
| 29 | + bool enabled = false; |
| 30 | +}; |
| 31 | + |
| 32 | +struct Resolution { |
| 33 | + std::string stdCanonical; // "c++26" / "c++2c" / "c++23" |
| 34 | + int stdLevel = 26; |
| 35 | + std::vector<std::string> flags; // union of enabled gate flags, deduped |
| 36 | + std::vector<FeatureState> features; // enabled + skipped, declaration order |
| 37 | +}; |
| 38 | + |
| 39 | +// Leading integer of Toolchain::version ("16.1.0" → 16; unparsable → 0). |
| 40 | +int compiler_major(const Toolchain& tc); |
| 41 | + |
| 42 | +// Latest -std= canonical the resolved toolchain accepts. Used for both |
| 43 | +// c++fly and c++latest (the raw canonicals are not valid -std= spellings). |
| 44 | +std::string latest_std_canonical(const Toolchain& tc, int* levelOut = nullptr); |
| 45 | + |
| 46 | +// The full c++fly answer for a toolchain: latest level + every gate it |
| 47 | +// supports (enabled) and every gate it lacks (skipped, with reason). |
| 48 | +Resolution resolve(const Toolchain& tc); |
| 49 | + |
| 50 | +// The dialect-complete std flag for any normalized standard, including |
| 51 | +// c++latest/c++fly which resolve per-toolchain. Plain canonicals delegate |
| 52 | +// to std_flag_for unchanged. |
| 53 | +std::string std_flag(const Toolchain& tc, std::string_view canonical, int level); |
| 54 | + |
| 55 | +// Graph-global dialect flags: manifest-declared ∪ (experimental ? fly gate |
| 56 | +// flags : ∅), deduped, declaration order kept. The ONE merge both consumers |
| 57 | +// (BuildPlan::dialectFlags and prepare's stdFlagAndDialect) go through so |
| 58 | +// scan-time, prebuild-time and compile-time dialect provably agree. |
| 59 | +std::vector<std::string> effective_dialect_flags(const Toolchain& tc, |
| 60 | + bool experimental, std::vector<std::string> manifestDialectFlags); |
| 61 | + |
| 62 | +} // namespace mcpp::toolchain::cppfly |
| 63 | + |
| 64 | +namespace mcpp::toolchain::cppfly { |
| 65 | + |
| 66 | +namespace { |
| 67 | + |
| 68 | +// ── Table 1: family × min major → latest supported -std= canonical ────── |
| 69 | +// First matching row wins (rows per family ordered newest-first). |
| 70 | +struct LatestStdRule { |
| 71 | + CompilerId family; |
| 72 | + int minMajor; |
| 73 | + std::string_view canonical; |
| 74 | + int level; |
| 75 | +}; |
| 76 | +constexpr LatestStdRule kLatestStd[] = { |
| 77 | + { CompilerId::GCC, 14, "c++26", 26 }, |
| 78 | + { CompilerId::GCC, 0, "c++23", 23 }, |
| 79 | + { CompilerId::Clang, 17, "c++2c", 26 }, |
| 80 | + { CompilerId::Clang, 0, "c++23", 23 }, |
| 81 | + // MSVC has no /std:c++26 — level > 20 is spelled /std:c++latest by |
| 82 | + // std_flag_for; the canonical here only feeds diagnostics. |
| 83 | + { CompilerId::MSVC, 0, "c++26", 26 }, |
| 84 | +}; |
| 85 | + |
| 86 | +// ── Table 2: experimental language-feature gates (version-gated) ──────── |
| 87 | +// A family with no row = unsupported. flags == "" = supported at the fly |
| 88 | +// std level with no extra gate flag (still reported for the summary). |
| 89 | +struct GateRule { |
| 90 | + CompilerId family; |
| 91 | + int minMajor; |
| 92 | + std::string_view flags; |
| 93 | +}; |
| 94 | +constexpr GateRule kReflectionRules[] = { |
| 95 | + { CompilerId::GCC, 16, "-freflection" }, |
| 96 | +}; |
| 97 | +constexpr GateRule kContractsRules[] = { |
| 98 | + { CompilerId::GCC, 16, "" }, |
| 99 | +}; |
| 100 | +struct Gate { |
| 101 | + std::string_view name; |
| 102 | + std::string_view paper; |
| 103 | + std::span<const GateRule> rules; |
| 104 | +}; |
| 105 | +constexpr Gate kGates[] = { |
| 106 | + { "reflection", "P2996", kReflectionRules }, |
| 107 | + { "contracts", "P2900", kContractsRules }, |
| 108 | +}; |
| 109 | + |
| 110 | +// ── Table 3: stdlib experimental gates (stdlib dimension) ─────────────── |
| 111 | +struct StdlibGateRule { |
| 112 | + std::string_view name; |
| 113 | + std::string_view stdlibId; |
| 114 | + std::string_view flags; |
| 115 | +}; |
| 116 | +constexpr StdlibGateRule kStdlibGates[] = { |
| 117 | + // libstdc++ and MSVC STL ship their unstable bits ungated; libc++ hides |
| 118 | + // them behind -fexperimental-library. |
| 119 | + { "experimental-library", "libc++", "-fexperimental-library" }, |
| 120 | +}; |
| 121 | + |
| 122 | +void add_unique(std::vector<std::string>& v, std::string_view f) { |
| 123 | + if (f.empty()) return; |
| 124 | + if (std::find(v.begin(), v.end(), f) == v.end()) v.emplace_back(f); |
| 125 | +} |
| 126 | + |
| 127 | +} // namespace |
| 128 | + |
| 129 | +int compiler_major(const Toolchain& tc) { |
| 130 | + int major = 0; |
| 131 | + bool any = false; |
| 132 | + for (char c : tc.version) { |
| 133 | + if (c < '0' || c > '9') break; |
| 134 | + major = major * 10 + (c - '0'); |
| 135 | + any = true; |
| 136 | + } |
| 137 | + return any ? major : 0; |
| 138 | +} |
| 139 | + |
| 140 | +std::string latest_std_canonical(const Toolchain& tc, int* levelOut) { |
| 141 | + const int major = compiler_major(tc); |
| 142 | + for (auto& r : kLatestStd) { |
| 143 | + if (r.family != tc.compiler) continue; |
| 144 | + if (major >= r.minMajor) { |
| 145 | + if (levelOut) *levelOut = r.level; |
| 146 | + return std::string(r.canonical); |
| 147 | + } |
| 148 | + } |
| 149 | + if (levelOut) *levelOut = 26; // unknown family: newest ratified level |
| 150 | + return "c++26"; |
| 151 | +} |
| 152 | + |
| 153 | +Resolution resolve(const Toolchain& tc) { |
| 154 | + Resolution r; |
| 155 | + r.stdCanonical = latest_std_canonical(tc, &r.stdLevel); |
| 156 | + const int major = compiler_major(tc); |
| 157 | + for (auto& g : kGates) { |
| 158 | + FeatureState st; |
| 159 | + st.name = std::string(g.name); |
| 160 | + st.paper = std::string(g.paper); |
| 161 | + const GateRule* hit = nullptr; |
| 162 | + for (auto& rule : g.rules) { |
| 163 | + if (rule.family == tc.compiler) { hit = &rule; break; } |
| 164 | + } |
| 165 | + if (!hit) { |
| 166 | + st.reason = std::format("{}: unsupported", tc.compiler_name()); |
| 167 | + } else if (major < hit->minMajor) { |
| 168 | + st.reason = std::format("{} {} < {}", tc.compiler_name(), major, hit->minMajor); |
| 169 | + } else { |
| 170 | + st.enabled = true; |
| 171 | + st.flags = std::string(hit->flags); |
| 172 | + add_unique(r.flags, hit->flags); |
| 173 | + } |
| 174 | + r.features.push_back(std::move(st)); |
| 175 | + } |
| 176 | + for (auto& sg : kStdlibGates) { |
| 177 | + FeatureState st; |
| 178 | + st.name = std::string(sg.name); |
| 179 | + st.paper = "stdlib"; |
| 180 | + if (tc.stdlibId == sg.stdlibId) { |
| 181 | + st.enabled = true; |
| 182 | + st.flags = std::string(sg.flags); |
| 183 | + add_unique(r.flags, sg.flags); |
| 184 | + } else { |
| 185 | + st.reason = std::format("stdlib is {}, gate applies to {}", |
| 186 | + tc.stdlibId.empty() ? "unknown" : tc.stdlibId, sg.stdlibId); |
| 187 | + } |
| 188 | + r.features.push_back(std::move(st)); |
| 189 | + } |
| 190 | + return r; |
| 191 | +} |
| 192 | + |
| 193 | +std::string std_flag(const Toolchain& tc, std::string_view canonical, int level) { |
| 194 | + std::string resolvedCanonical(canonical); |
| 195 | + int resolvedLevel = level; |
| 196 | + // c++latest (999) / c++fly (1000): resolve to the family's real latest |
| 197 | + // level — the raw canonical is not a valid -std= spelling on GNU. |
| 198 | + if (level >= 999) resolvedCanonical = latest_std_canonical(tc, &resolvedLevel); |
| 199 | + return std_flag_for(dialect_for(tc), resolvedCanonical, resolvedLevel); |
| 200 | +} |
| 201 | + |
| 202 | +std::vector<std::string> effective_dialect_flags(const Toolchain& tc, |
| 203 | + bool experimental, std::vector<std::string> manifestDialectFlags) |
| 204 | +{ |
| 205 | + if (!experimental) return manifestDialectFlags; |
| 206 | + for (auto& f : resolve(tc).flags) add_unique(manifestDialectFlags, f); |
| 207 | + return manifestDialectFlags; |
| 208 | +} |
| 209 | + |
| 210 | +} // namespace mcpp::toolchain::cppfly |
0 commit comments