// mcpp.pm.mangle — multi-version coexistence (Level 1 of the dep

// resolver's three-step strategy).

//

// When the SemVer merger (`try_merge_semver`) fails because two

// transitive consumers of the same package can't share a version,

// the resolver picks one as "primary" (keeps its module name as

// authored) and rewrites the secondary copy under a mangled name so

// both BMIs can coexist in the build graph without ODR clashes.

//

// This module owns the **pure** half of that work:

// * `mangle_name` decides the mangled name format

// * `rewrite_module_decls` does a regex pass over a single .cppm

// file's text, rewriting module / import declarations whose name

// appears in a caller-supplied rename table.

//

// The orchestration half (deciding which package gets mangled,

// staging files into a per-build directory, splicing the staged

// PackageRoot into the resolver output) lives in `cli.cppm`.

export module mcpp.pm.mangle;

import std;

export namespace mcpp::pm {

// Mangled module name format: `<base>__v<major>_<minor>_<patch>__mcpp`.

// The double underscores keep the suffix outside the user namespace

// (C++ ABI reserves `__` for the implementation, so users can't

// collide), and the trailing `__mcpp` makes link-error backtraces

// obviously mcpp-generated rather than mistaken for hand-rolled.

//

// Dots in `version` become underscores so the result is a valid

// C++ module identifier (modules allow `.` but using it here would

// confuse partition-style readings later).

std::string mangle_name(std::string_view base, std::string_view version);

// Rewrite a single .cppm file's module / import declarations:

// * `(export )?module N;` → `(export )?module rename[N];`

// * `(export )?module N:P;` → `(export )?module rename[N]:P;`

// * `(export )?import N;` → `(export )?import rename[N];`

// * `(export )?import N:P;` → `(export )?import rename[N]:P;`

//

// Names not present in the `rename` table are left intact. Bare

// partition imports (`import :P;`) and the global module fragment

// (`module ;`) are also left intact — they don't name the enclosing

// module so they need no rewriting.

//

// Single-line comments and string literals are not parsed: the

// matcher requires the keyword (`module` / `import`) to be at the

// start of a logical line (whitespace-only prefix). That covers

// every real-world declaration site without needing a full lexer.

std::string rewrite_module_decls(

std::string_view source,

const std::map<std::string, std::string>& rename);

} // namespace mcpp::pm

namespace mcpp::pm {

std::string mangle_name(std::string_view base, std::string_view version) {

std::string vmangled;

vmangled.reserve(version.size());

for (char c : version) vmangled += (c == '.' ? '_' : c);

return std::format("{}__v{}__mcpp", base, vmangled);

}

namespace {

// Module names are dotted identifiers: [A-Za-z_][A-Za-z0-9_.]*

bool is_name_start(char c) {

return std::isalpha(static_cast<unsigned char>(c)) || c == '_';

}

bool is_name_cont(char c) {

return std::isalnum(static_cast<unsigned char>(c)) || c == '_' || c == '.';

}

// Skip whitespace (spaces, tabs) in `s` from `i`. Returns new index.

std::size_t skip_ws(std::string_view s, std::size_t i) {

while (i < s.size() && (s[i] == ' ' || s[i] == '\t')) ++i;

return i;

}

// Try to consume the keyword `kw` at position `i`, requiring word boundary.

// Returns the index past `kw`, or std::string::npos on miss.

std::size_t consume_keyword(std::string_view s, std::size_t i,

std::string_view kw)

{

if (i + kw.size() > s.size()) return std::string::npos;

if (s.substr(i, kw.size()) != kw) return std::string::npos;

std::size_t after = i + kw.size();

if (after < s.size() && is_name_cont(s[after])) return std::string::npos;

return after;

}

// Parse a dotted identifier starting at `i`. Returns end index (first

// position past the name) and the name slice. Returns npos if no name.

std::pair<std::size_t, std::string_view>

read_name(std::string_view s, std::size_t i)

{

if (i >= s.size() || !is_name_start(s[i])) return {std::string::npos, {}};

std::size_t start = i;

++i;

while (i < s.size() && is_name_cont(s[i])) ++i;

return {i, s.substr(start, i - start)};

}

} // namespace

std::string rewrite_module_decls(

std::string_view source,

const std::map<std::string, std::string>& rename)

{

if (rename.empty()) return std::string(source);

std::string out;

out.reserve(source.size());

std::size_t i = 0;

while (i < source.size()) {

// We're at the start of a logical line. Capture leading whitespace.

std::size_t lineStart = i;

std::size_t afterWs = skip_ws(source, i);

// Try to recognize `(export )?(module|import) NAME[:PART][; or ws]`.

// On any deviation, copy the line verbatim.

std::size_t cur = afterWs;

bool hasExport = false;

if (auto p = consume_keyword(source, cur, "export"); p != std::string::npos) {

hasExport = true;

cur = skip_ws(source, p);

}

std::string_view kw;

if (auto p = consume_keyword(source, cur, "module"); p != std::string::npos) {

kw = "module"; cur = p;

} else if (auto p = consume_keyword(source, cur, "import"); p != std::string::npos) {

kw = "import"; cur = p;

} else {

// Not a module/import line — emit the rest of the physical line.

std::size_t eol = source.find('\n', lineStart);

if (eol == std::string_view::npos) eol = source.size();

else ++eol;

out.append(source.substr(lineStart, eol - lineStart));

i = eol;

continue;

}

std::size_t afterKw = skip_ws(source, cur);

// Bare partition import / global module fragment: `import :P;` /

// `module ;` — no name to rename, copy verbatim.

if (afterKw < source.size() && (source[afterKw] == ':' || source[afterKw] == ';')) {

std::size_t eol = source.find('\n', lineStart);

if (eol == std::string_view::npos) eol = source.size();

else ++eol;

out.append(source.substr(lineStart, eol - lineStart));

i = eol;

continue;

}

auto [nameEnd, name] = read_name(source, afterKw);

if (nameEnd == std::string::npos) {

// Not a recognized declaration. Verbatim.

std::size_t eol = source.find('\n', lineStart);

if (eol == std::string_view::npos) eol = source.size();

else ++eol;

out.append(source.substr(lineStart, eol - lineStart));

i = eol;

continue;

}

// Look up the name in the rename table.

auto it = rename.find(std::string(name));

if (it == rename.end()) {

// No rewrite needed for this declaration; copy line verbatim.

std::size_t eol = source.find('\n', lineStart);

if (eol == std::string_view::npos) eol = source.size();

else ++eol;

out.append(source.substr(lineStart, eol - lineStart));

i = eol;

continue;

}

// Emit the rewritten prefix:

// <leading-ws>(export )?(module|import) <renamed>

// Keep whatever follows the name (`:P;` / `;` / extras) verbatim.

out.append(source.substr(lineStart, afterWs - lineStart)); // ws

if (hasExport) out.append("export ");

out.append(kw); out.append(" ");

out.append(it->second);

// Append the trailing portion (from nameEnd) up to and including

// the newline.

std::size_t eol = source.find('\n', nameEnd);

if (eol == std::string_view::npos) eol = source.size();

else ++eol;

out.append(source.substr(nameEnd, eol - nameEnd));

i = eol;

}

return out;

}

} // namespace mcpp::pm