t-ruby 0.0.1

data/lib/t_ruby/cli.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module TRuby
+  class CLI
+    HELP_TEXT = <<~HELP
+      t-ruby compiler (trc) v#{VERSION}
+
+      Usage:
+        trc <file.trb>           Compile a .trb file to .rb
+        trc --watch, -w          Watch input files and recompile on change
+        trc --decl <file.trb>    Generate .d.trb declaration file
+        trc --lsp                Start LSP server (for IDE integration)
+        trc --version, -v        Show version
+        trc --help, -h           Show this help
+
+      Examples:
+        trc hello.trb            Compile hello.trb to build/hello.rb
+        trc -w                   Watch all .trb files in current directory
+        trc -w src/              Watch all .trb files in src/ directory
+        trc --watch hello.trb    Watch specific file for changes
+        trc --decl hello.trb     Generate hello.d.trb declaration file
+        trc --lsp                Start language server for VS Code
+    HELP
+
+    def self.run(args)
+      new(args).run
+    end
+
+    def initialize(args)
+      @args = args
+    end
+
+    def run
+      if @args.empty? || @args.include?("--help") || @args.include?("-h")
+        puts HELP_TEXT
+        return
+      end
+
+      if @args.include?("--version") || @args.include?("-v")
+        puts "trc #{VERSION}"
+        return
+      end
+
+      if @args.include?("--lsp")
+        start_lsp_server
+        return
+      end
+
+      if @args.include?("--watch") || @args.include?("-w")
+        start_watch_mode
+        return
+      end
+
+      if @args.include?("--decl")
+        input_file = @args[@args.index("--decl") + 1]
+        generate_declaration(input_file)
+        return
+      end
+
+      input_file = @args.first
+      compile(input_file)
+    end
+
+    private
+
+    def start_lsp_server
+      server = LSPServer.new
+      server.run
+    end
+
+    def start_watch_mode
+      # Get paths to watch (everything after --watch or -w flag)
+      watch_index = @args.index("--watch") || @args.index("-w")
+      paths = @args[(watch_index + 1)..]
+
+      # Default to current directory if no paths specified
+      paths = ["."] if paths.empty?
+
+      config = Config.new
+      watcher = Watcher.new(paths: paths, config: config)
+      watcher.watch
+    end
+
+    def generate_declaration(input_file)
+      config = Config.new
+      generator = DeclarationGenerator.new
+
+      output_path = generator.generate_file(input_file, config.out_dir)
+      puts "Generated: #{input_file} -> #{output_path}"
+    rescue ArgumentError => e
+      puts "Error: #{e.message}"
+      exit 1
+    end
+
+    def compile(input_file)
+      config = Config.new
+      compiler = Compiler.new(config)
+
+      output_path = compiler.compile(input_file)
+      puts "Compiled: #{input_file} -> #{output_path}"
+    rescue ArgumentError => e
+      puts "Error: #{e.message}"
+      exit 1
+    end
+  end
+end

data/lib/t_ruby/compiler.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module TRuby
+  class Compiler
+    attr_reader :declaration_loader, :use_ir, :optimizer
+
+    def initialize(config, use_ir: true, optimize: true)
+      @config = config
+      @use_ir = use_ir
+      @optimize = optimize
+      @declaration_loader = DeclarationLoader.new
+      @optimizer = IR::Optimizer.new if use_ir && optimize
+      setup_declaration_paths
+    end
+
+    def compile(input_path)
+      unless File.exist?(input_path)
+        raise ArgumentError, "File not found: #{input_path}"
+      end
+
+      unless input_path.end_with?(".trb")
+        raise ArgumentError, "Expected .trb file, got: #{input_path}"
+      end
+
+      source = File.read(input_path)
+
+      # Parse with IR support
+      parser = Parser.new(source, use_combinator: @use_ir)
+      parse_result = parser.parse
+
+      # Transform source to Ruby code
+      output = @use_ir ? transform_with_ir(source, parser) : transform_legacy(source, parse_result)
+
+      out_dir = @config.out_dir
+      FileUtils.mkdir_p(out_dir)
+
+      base_filename = File.basename(input_path, ".trb")
+      output_path = File.join(out_dir, base_filename + ".rb")
+
+      File.write(output_path, output)
+
+      # Generate .rbs file if enabled in config
+      if @config.emit["rbs"]
+        if @use_ir && parser.ir_program
+          generate_rbs_from_ir(base_filename, out_dir, parser.ir_program)
+        else
+          generate_rbs_file(base_filename, out_dir, parse_result)
+        end
+      end
+
+      # Generate .d.trb file if enabled in config
+      if @config.emit["dtrb"]
+        generate_dtrb_file(input_path, out_dir)
+      end
+
+      output_path
+    end
+
+    # Compile to IR without generating output files
+    def compile_to_ir(input_path)
+      unless File.exist?(input_path)
+        raise ArgumentError, "File not found: #{input_path}"
+      end
+
+      source = File.read(input_path)
+      parser = Parser.new(source, use_combinator: true)
+      parser.parse
+      parser.ir_program
+    end
+
+    # Compile from IR program directly
+    def compile_from_ir(ir_program, output_path)
+      out_dir = File.dirname(output_path)
+      FileUtils.mkdir_p(out_dir)
+
+      # Optimize if enabled
+      program = ir_program
+      if @optimize && @optimizer
+        result = @optimizer.optimize(program)
+        program = result[:program]
+      end
+
+      # Generate Ruby code
+      generator = IRCodeGenerator.new
+      output = generator.generate(program)
+      File.write(output_path, output)
+
+      output_path
+    end
+
+    # Load external declarations from a file
+    def load_declaration(name)
+      @declaration_loader.load(name)
+    end
+
+    # Add a search path for declaration files
+    def add_declaration_path(path)
+      @declaration_loader.add_search_path(path)
+    end
+
+    # Get optimization statistics (only available after IR compilation)
+    def optimization_stats
+      @optimizer&.stats
+    end
+
+    private
+
+    def setup_declaration_paths
+      # Add default declaration paths
+      @declaration_loader.add_search_path(@config.out_dir)
+      @declaration_loader.add_search_path(@config.src_dir)
+      @declaration_loader.add_search_path("./types")
+      @declaration_loader.add_search_path("./lib/types")
+    end
+
+    # Transform using IR system (new approach)
+    def transform_with_ir(source, parser)
+      ir_program = parser.ir_program
+      return transform_legacy(source, parser.parse) unless ir_program
+
+      # Run optimization passes if enabled
+      if @optimize && @optimizer
+        result = @optimizer.optimize(ir_program)
+        ir_program = result[:program]
+      end
+
+      # Generate Ruby code using IR-aware generator
+      generator = IRCodeGenerator.new
+      generator.generate_with_source(ir_program, source)
+    end
+
+    # Legacy transformation using TypeErasure (backward compatible)
+    def transform_legacy(source, parse_result)
+      if parse_result[:type] == :success
+        eraser = TypeErasure.new(source)
+        eraser.erase
+      else
+        source
+      end
+    end
+
+    # Generate RBS from IR
+    def generate_rbs_from_ir(base_filename, out_dir, ir_program)
+      generator = IR::RBSGenerator.new
+      rbs_content = generator.generate(ir_program)
+
+      rbs_path = File.join(out_dir, base_filename + ".rbs")
+      File.write(rbs_path, rbs_content) unless rbs_content.strip.empty?
+    end
+
+    # Legacy RBS generation
+    def generate_rbs_file(base_filename, out_dir, parse_result)
+      generator = RBSGenerator.new
+      rbs_content = generator.generate(
+        parse_result[:functions] || [],
+        parse_result[:type_aliases] || []
+      )
+
+      rbs_path = File.join(out_dir, base_filename + ".rbs")
+      File.write(rbs_path, rbs_content) unless rbs_content.empty?
+    end
+
+    def generate_dtrb_file(input_path, out_dir)
+      generator = DeclarationGenerator.new
+      generator.generate_file(input_path, out_dir)
+    end
+  end
+
+  # IR-aware code generator for source-preserving transformation
+  class IRCodeGenerator
+    def initialize
+      @output = []
+    end
+
+    # Generate Ruby code from IR program
+    def generate(program)
+      generator = IR::CodeGenerator.new
+      generator.generate(program)
+    end
+
+    # Generate Ruby code while preserving source structure
+    def generate_with_source(program, source)
+      result = source.dup
+
+      # Collect type alias names to remove
+      type_alias_names = program.declarations
+        .select { |d| d.is_a?(IR::TypeAlias) }
+        .map(&:name)
+
+      # Collect interface names to remove
+      interface_names = program.declarations
+        .select { |d| d.is_a?(IR::Interface) }
+        .map(&:name)
+
+      # Remove type alias definitions
+      result = result.gsub(/^\s*type\s+\w+\s*=\s*.+?$\n?/, '')
+
+      # Remove interface definitions (multi-line)
+      result = result.gsub(/^\s*interface\s+\w+.*?^\s*end\s*$/m, '')
+
+      # Remove parameter type annotations using IR info
+      # Enhanced: Handle complex types (generics, unions, etc.)
+      result = erase_parameter_types(result)
+
+      # Remove return type annotations
+      result = erase_return_types(result)
+
+      # Clean up extra blank lines
+      result = result.gsub(/\n{3,}/, "\n\n")
+
+      result
+    end
+
+    private
+
+    # Erase parameter type annotations
+    def erase_parameter_types(source)
+      result = source.dup
+
+      # Match function definitions and remove type annotations from parameters
+      result.gsub!(/^(\s*def\s+\w+\s*\()([^)]+)(\)\s*)(?::\s*[^\n]+)?(\s*$)/) do |match|
+        indent = $1
+        params = $2
+        close_paren = $3
+        ending = $4
+
+        # Remove type annotations from each parameter
+        cleaned_params = remove_param_types(params)
+
+        "#{indent}#{cleaned_params}#{close_paren.rstrip}#{ending}"
+      end
+
+      result
+    end
+
+    # Remove type annotations from parameter list
+    def remove_param_types(params_str)
+      return params_str if params_str.strip.empty?
+
+      params = []
+      current = ""
+      depth = 0
+
+      params_str.each_char do |char|
+        case char
+        when "<", "[", "("
+          depth += 1
+          current += char
+        when ">", "]", ")"
+          depth -= 1
+          current += char
+        when ","
+          if depth == 0
+            params << clean_param(current.strip)
+            current = ""
+          else
+            current += char
+          end
+        else
+          current += char
+        end
+      end
+
+      params << clean_param(current.strip) unless current.empty?
+      params.join(", ")
+    end
+
+    # Clean a single parameter (remove type annotation)
+    def clean_param(param)
+      # Match: name: Type or name
+      if match = param.match(/^(\w+)\s*:/)
+        match[1]
+      else
+        param
+      end
+    end
+
+    # Erase return type annotations
+    def erase_return_types(source)
+      result = source.dup
+
+      # Remove return type: ): Type or ): Type<Foo> etc.
+      result.gsub!(/\)\s*:\s*[^\n]+?(?=\s*$)/m) do |match|
+        ")"
+      end
+
+      result
+    end
+  end
+
+  # Legacy Compiler for backward compatibility (no IR)
+  class LegacyCompiler < Compiler
+    def initialize(config)
+      super(config, use_ir: false, optimize: false)
+    end
+  end
+end

data/lib/t_ruby/config.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module TRuby
+  class Config
+    DEFAULT_CONFIG = {
+      "emit" => {
+        "rb" => true,
+        "rbs" => false,
+        "dtrb" => false
+      },
+      "paths" => {
+        "src" => "./src",
+        "out" => "./build"
+      },
+      "strict" => {
+        "rbs_compat" => true,
+        "null_safety" => false,
+        "inference" => "basic"
+      }
+    }.freeze
+
+    attr_reader :emit, :paths, :strict
+
+    def initialize(config_path = nil)
+      config = load_config(config_path)
+      @emit = config["emit"]
+      @paths = config["paths"]
+      @strict = config["strict"]
+    end
+
+    def out_dir
+      @paths["out"]
+    end
+
+    def src_dir
+      @paths["src"]
+    end
+
+    private
+
+    def load_config(config_path)
+      if config_path && File.exist?(config_path)
+        YAML.safe_load_file(config_path, permitted_classes: [Symbol])
+      elsif File.exist?(".trb.yml")
+        YAML.safe_load_file(".trb.yml", permitted_classes: [Symbol])
+      else
+        DEFAULT_CONFIG.dup
+      end
+    end
+  end
+end