MonomorphizedName.h

#pragma once
#include "util/QualifiedName.h"
#include <string>
 
namespace sammine_util {

struct MonomorphizedName {
  QualifiedName base;      // original name (preserves module)
  std::string type_args;   // "<i32>" or "<Option<i32>>" (includes brackets)
  std::string method_name; // "add" for typeclasses, "" for generics

  static MonomorphizedName generic(QualifiedName base, std::string type_args) {
    return {std::move(base), std::move(type_args), ""};
  }

  static MonomorphizedName typeclass(std::string class_name,
                                     std::string concrete_type_str,
                                     std::string method_name) {
    return {QualifiedName::local(std::move(class_name)),
            "<" + std::move(concrete_type_str) + ">",
            std::move(method_name)};
  }

  std::string instance_key() const { return base.mangled() + type_args; }

  std::string mangled() const {
    if (method_name.empty())
      return base.mangled() + type_args;
    return base.mangled() + type_args + "::" + method_name;
  }

  QualifiedName to_qualified_name() const {
    if (method_name.empty()) {
      // Generic: replace the last part of base with name + type_args
      auto parts = base.parts();
      parts.back() = base.get_name() + type_args;
      return QualifiedName::from_parts(std::move(parts));
    }
    // Typeclass: single-part local name so mangleName() can prepend module
    return QualifiedName::local(base.mangled() + type_args + "::" +
                                method_name);
  }
};
 
} // namespace sammine_util