Compiler_Driver.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_DRIVER_H
#define COMPILER_DRIVER_H
 
#include <sstream>
#include <string>
#include <string_view>
#include <utility>
 
#include <Bytecode.H>
#include <Compiler_Backend_C.H>
#include <Compiler_Driver_Contracts.H>
#include <Compiler_HIR_Lowering_MVP.H>
#include <Compiler_IR_Lowering_MVP.H>
#include <Compiler_Module_Resolver.H>
#include <Compiler_Parser.H>
#include <Interpreter_Runtime.H>
#include <tpl_dynArray.H>
 
namespace Aleph {
struct Compiler_Driver_Options
{
  Compiler_Parser_Options parser_options;  
  Compiler_Typed_Semantic_Options typed_semantic_options;  
  Interpreter_Runtime_Options runtime_options;             
  Compiler_C_Backend_Options c_backend_options;  
};
 
namespace Compiler_Driver_Detail {}
 
class Compiler_Driver
{
  Compiler_Driver_Options config_;
  Source_Manager sources_;
  Diagnostic_Engine diagnostics_;
  Compiler_Ast_Context ast_ctx_;
  Compiler_HIR_Context hir_ctx_;
  Compiler_IR_Context ir_ctx_;
  Compiler_Bytecode_Context bytecode_ctx_;
  Compiler_Typed_Semantic_Analyzer typed_;
  Interpreter_Runtime runtime_;
  size_t arena_bytes_ = 0;
 
  DynArray<std::string> source_names_;
  DynArray<Source_File_Id> source_file_ids_;
  DynArray<Compiler_Module *> parsed_modules_;
  DynArray<size_t> merge_order_;
  DynArray<Compiler_Driver_Artifact> artifacts_;
  DynArray<std::string> errors_;
  DynArray<std::string> warnings_;
 
  Compiler_Module *merged_ast_ = nullptr;
  Compiler_HIR_Module *hir_module_ = nullptr;
  Compiler_IR_Module *ir_module_ = nullptr;
  Compiler_Bytecode_Module *bytecode_module_ = nullptr;
  Compiler_C_Backend_Emission c_emission_;
  Compiler_Driver_Run_Output run_output_;
  Compiler_Driver_Action last_action_ = Compiler_Driver_Action::Parse_Only;
 
  void append_error(const std::string &text)
  {
    errors_.append(text);
  }
 
  void append_warning(const std::string &text)
  {
    warnings_.append(text);
  }
 
  void emit_driver_diagnostic(const Source_Span &span,
                              const std::string &code,
                              const std::string &message,
                              const std::string &note = "",
                              const std::string &help = "")
  {
    auto builder = diagnostics_.error(span, message).code(code);
    if (not note.empty())
      builder.note(note);
    if (not help.empty())
      builder.help(help);
    builder.emit();
  }
 
  void record_text_artifact(const std::string &label, std::string text)
  {
    Compiler_Driver_Detail::append_artifact(artifacts_, label, std::move(text));
  }
 
  size_t find_source_index(std::string_view name) const noexcept
  {
    for (size_t i = 0; i < source_names_.size(); ++i)
      if (source_names_.access(i) == name)
        return i;
    return static_cast<size_t>(-1);
  }
 
  void record_import_order_artifact()
  {
    DynArray<Compiler_Module_Descriptor> modules;
    for (size_t i = 0; i < source_names_.size(); ++i)
      modules.append({source_names_.access(i), {}});
    record_text_artifact("imports.order", compiler_render_module_order(merge_order_, modules));
  }
 
  void record_ast_artifacts()
  {
    for (size_t i = 0; i < parsed_modules_.size(); ++i)
      record_text_artifact(Compiler_Driver_Detail::artifact_label("ast", i, source_names_.access(i)),
                           compiler_dump_module(parsed_modules_.access(i)));
 
    record_import_order_artifact();
    record_text_artifact("ast", compiler_dump_module(merged_ast_));
  }
 
  bool resolve_import_order()
  {
    merge_order_.clear();
 
    DynArray<Compiler_Module_Descriptor> modules;
    for (size_t i = 0; i < parsed_modules_.size(); ++i)
      {
        Compiler_Module_Descriptor module;
        module.name = source_names_.access(i);
        const auto *parsed = parsed_modules_.access(i);
        if (parsed != nullptr)
          for (size_t j = 0; j < parsed->imports.size(); ++j)
            {
              const auto *decl = parsed->imports.access(j);
              if (decl == nullptr or decl->kind != Compiler_Import_Decl_Kind::Import)
                continue;
              module.imports.append({decl->module_name, decl->module_name_span});
            }
        modules.append(std::move(module));
      }
 
    const auto result = compiler_resolve_module_order(modules);
    for (size_t i = 0; i < result.issues.size(); ++i)
      {
        const auto &issue = result.issues.access(i);
        if (issue.kind == Compiler_Module_Resolution_Issue_Kind::Missing_Dependency)
          emit_driver_diagnostic(issue.span,
                                 "DRV001",
                                 "cannot resolve import '" + issue.dependency_name + "'",
                                 "known sources must match import names exactly");
        else
          emit_driver_diagnostic(issue.span,
                                 "DRV002",
                                 "cyclic import involving '" + issue.module_name + "' and '"
                                   + issue.dependency_name + "'",
                                 "imports currently form one acyclic source-order graph");
      }
 
    for (size_t i = 0; i < result.order.size(); ++i)
      merge_order_.append(result.order.access(i));
 
    return result.valid and not diagnostics_.has_errors();
  }
 
  void merge_modules_from_order()
  {
    merged_ast_ = ast_ctx_.make<Compiler_Module>();
    merged_ast_->source_name = "<merged>";
 
    Source_Span first_span;
    Source_Span last_span;
 
    for (size_t i = 0; i < merge_order_.size(); ++i)
      {
        const auto module_index = merge_order_.access(i);
        const auto *module = parsed_modules_.access(module_index);
        if (module == nullptr)
          continue;
 
        if (not first_span.is_valid() and module->span.is_valid())
          first_span = module->span;
        if (module->span.is_valid())
          last_span = module->span;
 
        for (size_t j = 0; j < module->type_declarations.size(); ++j)
          merged_ast_->type_declarations.append(module->type_declarations.access(j));
        for (size_t j = 0; j < module->functions.size(); ++j)
          merged_ast_->functions.append(module->functions.access(j));
        for (size_t j = 0; j < module->statements.size(); ++j)
          merged_ast_->statements.append(module->statements.access(j));
      }
 
    if (first_span.is_valid())
      merged_ast_->span = compiler_merge_spans(first_span, last_span);
  }
 
  void record_diagnostics_artifact()
  {
    std::ostringstream out;
    diagnostics_.render_plain(out);
    record_text_artifact("diagnostics", out.str());
  }
 
  void record_driver_messages_artifact()
  {
    record_text_artifact("driver.messages",
                         Compiler_Driver_Detail::render_messages(errors_, warnings_));
  }
 
  bool parse_registered_sources()
  {
    parsed_modules_.clear();
 
    for (size_t i = 0; i < source_file_ids_.size(); ++i)
      {
        Compiler_Parser parser(
          ast_ctx_, sources_, source_file_ids_.access(i), &diagnostics_, config_.parser_options);
        parsed_modules_.append(parser.parse_module());
      }
 
    if (not resolve_import_order())
      {
        if (merge_order_.is_empty())
          for (size_t i = 0; i < parsed_modules_.size(); ++i)
            merge_order_.append(i);
      }
 
    merge_modules_from_order();
 
    record_ast_artifacts();
    return not diagnostics_.has_errors();
  }
 
  bool run_typed_semantics()
  {
    typed_.analyze_module(merged_ast_);
    record_text_artifact("typed-sema", typed_.dump_inference());
    return not diagnostics_.has_errors();
  }
 
  bool lower_hir()
  {
    Compiler_HIR_Lowering lowering(hir_ctx_, typed_);
    hir_module_ = lowering.lower_module(merged_ast_);
    record_text_artifact("hir", compiler_dump_hir_module(hir_module_, typed_.type_context()));
    return hir_module_ != nullptr;
  }
 
  bool lower_ir()
  {
    Compiler_IR_Lowering lowering(ir_ctx_);
    ir_module_ = lowering.lower_module(hir_module_);
    record_text_artifact("ir", compiler_dump_ir_module(ir_module_, &typed_.type_context()));
 
    if (ir_module_ == nullptr)
      {
        append_error("ir: null IR module produced by lowering");
        return false;
      }
 
    const auto report = validate_ir_module(*ir_module_);
    return Compiler_Driver_Detail::merge_report("ir", report, errors_, warnings_);
  }
 
  bool lower_bytecode()
  {
    Compiler_Bytecode_Lowering lowering(bytecode_ctx_);
    bytecode_module_ = lowering.lower_module(ir_module_);
    record_text_artifact("bytecode",
                         compiler_dump_bytecode_module(bytecode_module_, &typed_.type_context()));
 
    if (bytecode_module_ == nullptr)
      {
        append_error("bytecode: null bytecode module produced by lowering");
        return false;
      }
 
    const auto report = validate_bytecode_module(*bytecode_module_);
    return Compiler_Driver_Detail::merge_report("bytecode", report, errors_, warnings_);
  }
 
  bool emit_c()
  {
    c_emission_ = compiler_emit_c_module(ir_module_, config_.c_backend_options);
    record_text_artifact("emit-c", c_emission_.source);
    return Compiler_Driver_Detail::merge_report("emit-c", c_emission_, errors_, warnings_);
  }
 
  bool execute_hir_runtime()
  {
    run_output_ = {};
    run_output_.executed = true;
    run_output_.result = runtime_.evaluate_module(hir_module_);
    if (run_output_.result.ok())
      run_output_.value_text = interpreter_value_to_string(run_output_.result.value);
    else
      run_output_.value_text = "";
    run_output_.globals_text = interpreter_dump_globals(runtime_);
 
    record_text_artifact("run.result", Compiler_Driver_Detail::render_run_result(run_output_));
    record_text_artifact("run.globals", run_output_.globals_text);
    return run_output_.result.ok();
  }
 
  void append_run_failure_if_needed()
  {
    if (run_output_.result.ok())
      return;
 
    std::string message = "run: HIR runtime execution failed";
    if (not run_output_.result.error.code.empty() or not run_output_.result.error.message.empty())
      {
        message += ":";
        if (not run_output_.result.error.code.empty())
          message += " " + run_output_.result.error.code;
        if (not run_output_.result.error.message.empty())
          {
            if (not run_output_.result.error.code.empty())
              message += " ";
            message += run_output_.result.error.message;
          }
      }
    append_error(message);
  }
 
  bool finalize(const Compiler_Driver_Action action)
  {
    last_action_ = action;
    record_driver_messages_artifact();
    record_diagnostics_artifact();
    return ok();
  }
 
  bool prepare_inputs(const DynArray<Compiler_Driver_Source> &inputs)
  {
    if (inputs.is_empty())
      {
        append_error("driver: no input sources were provided");
        return false;
      }
 
    for (size_t i = 0; i < inputs.size(); ++i)
      {
        const auto &input = inputs.access(i);
        if (find_source_index(input.name) != static_cast<size_t>(-1))
          {
            append_error("driver: duplicate input source name '" + input.name + "'");
            return false;
          }
        source_names_.append(input.name);
        source_file_ids_.append(sources_.add_virtual_file(input.name, input.text));
      }
 
    return true;
  }
 
public:
  explicit Compiler_Driver(const Compiler_Driver_Options &options = {},
                           const size_t arena_size = 1 << 20)
    : config_(options), diagnostics_(sources_), ast_ctx_(arena_size), hir_ctx_(arena_size),
      ir_ctx_(arena_size), bytecode_ctx_(arena_size),
      typed_(&diagnostics_, options.typed_semantic_options),
      runtime_(&diagnostics_, options.runtime_options), arena_bytes_(arena_size)
  {}
 
  Compiler_Driver(const Compiler_Driver &) = delete;
  Compiler_Driver &operator=(const Compiler_Driver &) = delete;
 
  [[nodiscard]] const Compiler_Driver_Options &options() const noexcept
  {
    return config_;
  }
 
  [[nodiscard]] size_t arena_size() const noexcept
  {
    return arena_bytes_;
  }
 
  void clear() noexcept
  {
    parsed_modules_.clear();
    merge_order_.clear();
    source_names_.clear();
    source_file_ids_.clear();
    artifacts_.clear();
    errors_.clear();
    warnings_.clear();
 
    merged_ast_ = nullptr;
    hir_module_ = nullptr;
    ir_module_ = nullptr;
    bytecode_module_ = nullptr;
    c_emission_ = {};
    run_output_ = {};
    last_action_ = Compiler_Driver_Action::Parse_Only;
 
    runtime_.reset();
    runtime_.set_diagnostics(&diagnostics_);
    typed_.clear();
    diagnostics_.clear();
    ast_ctx_.reset();
    hir_ctx_.reset();
    ir_ctx_.reset();
    bytecode_ctx_.reset();
    sources_ = Source_Manager();
  }
 
  bool bind_host_function(const std::string &name,
                          const Interpreter_Host_Function callback,
                          void *user_data = nullptr)
  {
    return runtime_.bind_host_function(name, callback, user_data);
  }
 
  bool execute_sources(const DynArray<Compiler_Driver_Source> &inputs,
                       const Compiler_Driver_Action action = Compiler_Driver_Action::Run)
  {
    clear();
    if (not prepare_inputs(inputs))
      return finalize(action);
    if (not parse_registered_sources())
      return finalize(action);
    if (action == Compiler_Driver_Action::Parse_Only)
      return finalize(action);
 
    if (not run_typed_semantics())
      return finalize(action);
    if (action == Compiler_Driver_Action::Sema_Only)
      return finalize(action);
 
    if (not lower_hir())
      {
        append_error("hir: failed to lower merged AST to HIR");
        return finalize(action);
      }
    if (action == Compiler_Driver_Action::HIR)
      return finalize(action);
 
    if (action == Compiler_Driver_Action::Run)
      {
        if (not execute_hir_runtime())
          append_run_failure_if_needed();
        return finalize(action);
      }
 
    if (not lower_ir())
      return finalize(action);
    if (action == Compiler_Driver_Action::IR)
      return finalize(action);
 
    switch (action)
      {
      case Compiler_Driver_Action::Emit_Bytecode:
        (void) lower_bytecode();
        return finalize(action);
 
      case Compiler_Driver_Action::Emit_C:
        (void) emit_c();
        return finalize(action);
 
      case Compiler_Driver_Action::Parse_Only:
      case Compiler_Driver_Action::Sema_Only:
      case Compiler_Driver_Action::HIR:
      case Compiler_Driver_Action::IR:
      case Compiler_Driver_Action::Run:
        return finalize(action);
      }
 
    append_error("driver: reached unreachable action dispatch");
    return finalize(action);
  }
 
  bool execute_files(const DynArray<std::string> &paths,
                     const Compiler_Driver_Action action = Compiler_Driver_Action::Run)
  {
    clear();
    if (paths.is_empty())
      {
        append_error("driver: no input file paths were provided");
        return finalize(action);
      }
 
    for (size_t i = 0; i < paths.size(); ++i)
      {
        const auto &path = paths.access(i);
        if (find_source_index(path) != static_cast<size_t>(-1))
          {
            append_error("driver: duplicate input file path '" + path + "'");
            return finalize(action);
          }
        source_names_.append(path);
        source_file_ids_.append(sources_.load_file(path));
      }
 
    if (not parse_registered_sources())
      return finalize(action);
    if (action == Compiler_Driver_Action::Parse_Only)
      return finalize(action);
 
    if (not run_typed_semantics())
      return finalize(action);
    if (action == Compiler_Driver_Action::Sema_Only)
      return finalize(action);
 
    if (not lower_hir())
      {
        append_error("hir: failed to lower merged AST to HIR");
        return finalize(action);
      }
    if (action == Compiler_Driver_Action::HIR)
      return finalize(action);
 
    if (action == Compiler_Driver_Action::Run)
      {
        if (not execute_hir_runtime())
          append_run_failure_if_needed();
        return finalize(action);
      }
 
    if (not lower_ir())
      return finalize(action);
    if (action == Compiler_Driver_Action::IR)
      return finalize(action);
 
    if (action == Compiler_Driver_Action::Emit_Bytecode)
      {
        (void) lower_bytecode();
        return finalize(action);
      }
 
    if (action == Compiler_Driver_Action::Emit_C)
      {
        (void) emit_c();
        return finalize(action);
      }
 
    append_error("driver: reached unreachable file-action dispatch");
    return finalize(action);
  }
 
  bool execute_source(const std::string &name,
                      const std::string &text,
                      const Compiler_Driver_Action action = Compiler_Driver_Action::Run)
  {
    DynArray<Compiler_Driver_Source> inputs;
    inputs.append({name, text});
    return execute_sources(inputs, action);
  }
 
  [[nodiscard]] bool ok() const noexcept
  {
    return errors_.is_empty() and not diagnostics_.has_errors();
  }
 
  [[nodiscard]] Compiler_Driver_Action last_action() const noexcept
  {
    return last_action_;
  }
 
  [[nodiscard]] const Source_Manager &source_manager() const noexcept
  {
    return sources_;
  }
 
  [[nodiscard]] const Diagnostic_Engine &diagnostic_engine() const noexcept
  {
    return diagnostics_;
  }
 
  [[nodiscard]] const Compiler_Typed_Semantic_Analyzer &typed_analysis() const noexcept
  {
    return typed_;
  }
 
  [[nodiscard]] const DynArray<Compiler_Module *> &parsed_ast_modules() const noexcept
  {
    return parsed_modules_;
  }
 
  [[nodiscard]] const Compiler_Module *merged_ast_module() const noexcept
  {
    return merged_ast_;
  }
 
  [[nodiscard]] const Compiler_HIR_Module *hir_module() const noexcept
  {
    return hir_module_;
  }
 
  [[nodiscard]] const Compiler_IR_Module *ir_module() const noexcept
  {
    return ir_module_;
  }
 
  [[nodiscard]] const Compiler_Bytecode_Module *bytecode_module() const noexcept
  {
    return bytecode_module_;
  }
 
  [[nodiscard]] const Compiler_C_Backend_Emission &c_emission() const noexcept
  {
    return c_emission_;
  }
 
  [[nodiscard]] const Compiler_Driver_Run_Output &run_output() const noexcept
  {
    return run_output_;
  }
 
  [[nodiscard]] const DynArray<std::string> &errors() const noexcept
  {
    return errors_;
  }
 
  [[nodiscard]] const DynArray<std::string> &warnings() const noexcept
  {
    return warnings_;
  }
 
  [[nodiscard]] const DynArray<Compiler_Driver_Artifact> &artifacts() const noexcept
  {
    return artifacts_;
  }
 
  [[nodiscard]] const Compiler_Driver_Artifact *find_artifact(std::string_view label) const noexcept
  {
    for (size_t i = artifacts_.size(); i > 0; --i)
      if (artifacts_.access(i - 1).label == label)
        return &artifacts_.access(i - 1);
    return nullptr;
  }
 
  [[nodiscard]] std::string diagnostics_text() const
  {
    std::ostringstream out;
    diagnostics_.render_plain(out);
    return out.str();
  }
};
}  // namespace Aleph
 
#endif