Compiler_Types.H

Go to the documentation of this file.

/*
                          Aleph_w
 
  Data structures & Algorithms
  version 2.0.0b
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
#ifndef COMPILER_TYPES_H
#define COMPILER_TYPES_H
 
#include <initializer_list>
#include <sstream>
#include <string>
#include <utility>
 
#include <ah-errors.H>
#include <tpl_dynArray.H>
 
namespace Aleph {
using Compiler_Type_Id = size_t;
 
enum class Compiler_Type_Kind
{
  Builtin,
  Tuple,
  Function,
  Struct,
  Enum,
  Type_Variable
};
 
enum class Compiler_Builtin_Type
{
  Invalid,
  Unit,
  Bool,
  Integer,
  String,
  Character
};
 
inline const char *compiler_type_kind_name(const Compiler_Type_Kind kind) noexcept
{
  switch (kind)
    {
    case Compiler_Type_Kind::Builtin:
      return "Builtin";
    case Compiler_Type_Kind::Tuple:
      return "Tuple";
    case Compiler_Type_Kind::Function:
      return "Function";
    case Compiler_Type_Kind::Struct:
      return "Struct";
    case Compiler_Type_Kind::Enum:
      return "Enum";
    case Compiler_Type_Kind::Type_Variable:
      return "Type_Variable";
    }
 
  return "Unknown";
}
 
inline const char *compiler_builtin_type_name(const Compiler_Builtin_Type builtin) noexcept
{
  switch (builtin)
    {
    case Compiler_Builtin_Type::Invalid:
      return "Invalid";
    case Compiler_Builtin_Type::Unit:
      return "Unit";
    case Compiler_Builtin_Type::Bool:
      return "Bool";
    case Compiler_Builtin_Type::Integer:
      return "Int";
    case Compiler_Builtin_Type::String:
      return "String";
    case Compiler_Builtin_Type::Character:
      return "Char";
    }
 
  return "Unknown";
}
 
struct Compiler_Type
{
  Compiler_Type_Id id = 0;                                         
  Compiler_Type_Kind kind = Compiler_Type_Kind::Builtin;           
  Compiler_Builtin_Type builtin = Compiler_Builtin_Type::Invalid;  
  DynArray<Compiler_Type_Id> components;  
  Compiler_Type_Id result_type = 0;       
  DynArray<std::string> member_names;  
  std::string label;                   
  bool rigid = false;                  
 
  bool is_builtin() const noexcept
  {
    return kind == Compiler_Type_Kind::Builtin;
  }
 
  bool is_type_variable() const noexcept
  {
    return kind == Compiler_Type_Kind::Type_Variable;
  }
 
  bool is_struct() const noexcept
  {
    return kind == Compiler_Type_Kind::Struct;
  }
 
  bool is_enum() const noexcept
  {
    return kind == Compiler_Type_Kind::Enum;
  }
};
 
class Compiler_Type_Context
{
  DynArray<Compiler_Type> types;
  size_t builtin_type_count = 0;
  size_t next_type_variable_index = 0;
 
  Compiler_Type_Id invalid_id = 0;
  Compiler_Type_Id unit_id = 0;
  Compiler_Type_Id bool_id = 0;
  Compiler_Type_Id integer_id = 0;
  Compiler_Type_Id string_id = 0;
  Compiler_Type_Id character_id = 0;
 
  Compiler_Type_Id append_type(Compiler_Type type)
  {
    type.id = types.size() + 1;
    types.append(std::move(type));
    return types.size();
  }
 
  Compiler_Type &mutable_type(const Compiler_Type_Id id) const
  {
    ah_out_of_range_error_unless(id > 0 and id <= types.size())
      << "Compiler_Type_Context::mutable_type(): invalid id " << id;
    return types.access(id - 1);
  }
 
  void initialize_builtins()
  {
    auto add_builtin = [this](const Compiler_Builtin_Type builtin)
    {
      Compiler_Type type;
      type.kind = Compiler_Type_Kind::Builtin;
      type.builtin = builtin;
      return append_type(std::move(type));
    };
 
    invalid_id = add_builtin(Compiler_Builtin_Type::Invalid);
    unit_id = add_builtin(Compiler_Builtin_Type::Unit);
    bool_id = add_builtin(Compiler_Builtin_Type::Bool);
    integer_id = add_builtin(Compiler_Builtin_Type::Integer);
    string_id = add_builtin(Compiler_Builtin_Type::String);
    character_id = add_builtin(Compiler_Builtin_Type::Character);
    builtin_type_count = types.size();
  }
 
  static DynArray<Compiler_Type_Id> list_to_array(const std::initializer_list<Compiler_Type_Id> ids)
  {
    DynArray<Compiler_Type_Id> result;
    for (const auto id : ids)
      result.append(id);
    return result;
  }
 
  void append_type_text(std::ostream &out, const Compiler_Type_Id id) const
  {
    const auto &ty = type(id);
    switch (ty.kind)
      {
      case Compiler_Type_Kind::Builtin:
        out << compiler_builtin_type_name(ty.builtin);
        return;
 
      case Compiler_Type_Kind::Type_Variable:
        out << ty.label;
        if (ty.rigid)
          out << '!';
        return;
 
      case Compiler_Type_Kind::Tuple:
        out << '(';
        for (size_t i = 0; i < ty.components.size(); ++i)
          {
            if (i > 0)
              out << ", ";
            append_type_text(out, ty.components.access(i));
          }
        out << ')';
        return;
 
      case Compiler_Type_Kind::Function:
        out << "fn(";
        for (size_t i = 0; i < ty.components.size(); ++i)
          {
            if (i > 0)
              out << ", ";
            append_type_text(out, ty.components.access(i));
          }
        out << ") -> ";
        append_type_text(out, ty.result_type);
        return;
 
      case Compiler_Type_Kind::Struct:
      case Compiler_Type_Kind::Enum:
        out << ty.label;
        return;
      }
  }
 
public:
  Compiler_Type_Context()
  {
    initialize_builtins();
  }
 
  void clear() noexcept
  {
    types.clear();
    builtin_type_count = 0;
    next_type_variable_index = 0;
    invalid_id = 0;
    unit_id = 0;
    bool_id = 0;
    integer_id = 0;
    string_id = 0;
    character_id = 0;
    initialize_builtins();
  }
 
  size_t size() const noexcept
  {
    return types.size();
  }
 
  size_t builtin_count() const noexcept
  {
    return builtin_type_count;
  }
 
  Compiler_Type_Id invalid_type() const noexcept
  {
    return invalid_id;
  }
 
  Compiler_Type_Id unit_type() const noexcept
  {
    return unit_id;
  }
 
  Compiler_Type_Id bool_type() const noexcept
  {
    return bool_id;
  }
 
  Compiler_Type_Id integer_type() const noexcept
  {
    return integer_id;
  }
 
  Compiler_Type_Id string_type() const noexcept
  {
    return string_id;
  }
 
  Compiler_Type_Id character_type() const noexcept
  {
    return character_id;
  }
 
  const Compiler_Type &type(const Compiler_Type_Id id) const
  {
    ah_out_of_range_error_unless(id > 0 and id <= types.size())
      << "Compiler_Type_Context::type(): invalid id " << id;
    return types.access(id - 1);
  }
 
  bool is_type_variable(const Compiler_Type_Id id) const
  {
    return type(id).kind == Compiler_Type_Kind::Type_Variable;
  }
 
  bool is_builtin(const Compiler_Type_Id id) const
  {
    return type(id).kind == Compiler_Type_Kind::Builtin;
  }
 
  bool is_struct(const Compiler_Type_Id id) const
  {
    return type(id).kind == Compiler_Type_Kind::Struct;
  }
 
  bool is_enum(const Compiler_Type_Id id) const
  {
    return type(id).kind == Compiler_Type_Kind::Enum;
  }
 
  Compiler_Type_Id make_type_variable(std::string label = "", const bool rigid = false)
  {
    Compiler_Type ty;
    ty.kind = Compiler_Type_Kind::Type_Variable;
    ty.rigid = rigid;
    ty.label = label.empty() ? ("T" + std::to_string(next_type_variable_index++)) : std::move(label);
    return append_type(std::move(ty));
  }
 
  Compiler_Type_Id make_tuple_type(const DynArray<Compiler_Type_Id> &members)
  {
    Compiler_Type ty;
    ty.kind = Compiler_Type_Kind::Tuple;
    ty.components = members;
    return append_type(std::move(ty));
  }
 
  Compiler_Type_Id make_tuple_type(const std::initializer_list<Compiler_Type_Id> members)
  {
    return make_tuple_type(list_to_array(members));
  }
 
  Compiler_Type_Id make_function_type(const DynArray<Compiler_Type_Id> &parameters,
                                      const Compiler_Type_Id result)
  {
    Compiler_Type ty;
    ty.kind = Compiler_Type_Kind::Function;
    ty.components = parameters;
    ty.result_type = result;
    return append_type(std::move(ty));
  }
 
  Compiler_Type_Id make_function_type(const std::initializer_list<Compiler_Type_Id> parameters,
                                      const Compiler_Type_Id result)
  {
    return make_function_type(list_to_array(parameters), result);
  }
 
  Compiler_Type_Id make_struct_type(std::string name)
  {
    Compiler_Type ty;
    ty.kind = Compiler_Type_Kind::Struct;
    ty.label = std::move(name);
    return append_type(std::move(ty));
  }
 
  void set_struct_fields(const Compiler_Type_Id id,
                         const DynArray<std::string> &field_names,
                         const DynArray<Compiler_Type_Id> &field_types) const
  {
    auto &ty = mutable_type(id);
    ah_invalid_argument_unless(ty.kind == Compiler_Type_Kind::Struct)
      << "Compiler_Type_Context::set_struct_fields(): id " << id << " is not a struct";
    ah_invalid_argument_unless(field_names.size() == field_types.size())
      << "Compiler_Type_Context::set_struct_fields(): mismatched field name/type arity";
    ty.member_names = field_names;
    ty.components = field_types;
  }
 
  Compiler_Type_Id make_enum_type(std::string name)
  {
    Compiler_Type ty;
    ty.kind = Compiler_Type_Kind::Enum;
    ty.label = std::move(name);
    return append_type(std::move(ty));
  }
 
  void set_enum_variants(const Compiler_Type_Id id, const DynArray<std::string> &variant_names) const
  {
    auto &ty = mutable_type(id);
    ah_invalid_argument_unless(ty.kind == Compiler_Type_Kind::Enum)
      << "Compiler_Type_Context::set_enum_variants(): id " << id << " is not an enum";
    ty.member_names = variant_names;
  }
 
  std::string to_string(const Compiler_Type_Id id) const
  {
    std::ostringstream out;
    append_type_text(out, id);
    return out.str();
  }
 
  std::string dump_types() const
  {
    std::ostringstream out;
    out << "Types\n";
    for (size_t i = 0; i < types.size(); ++i)
      {
        const auto &ty = types.access(i);
        out << "  #" << ty.id << " " << compiler_type_kind_name(ty.kind) << " " << to_string(ty.id)
            << '\n';
      }
    return out.str();
  }
};
}  // namespace Aleph
 
#endif  // COMPILER_TYPES_H