t-ruby 0.0.41 → 0.0.43

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a7c7a93e1498a150b541ea7f7838c08435a33ead72774b7e4c0b8ead951e9d3
-  data.tar.gz: 1fbfb9ea6b276e130ef04891f39d691e362d5352dc4f0209b00009105f13c3a0
+  metadata.gz: cb406ad473738afc16343a01b9f7e8e0f77a8b0fe700dd3ced2df65197bce626
+  data.tar.gz: 95f1ce4ede5378e17393046c223c46b404d95e6506235e210aeba20a9615f8ac
 SHA512:
-  metadata.gz: 82cbc96204194f51b65f484aeda25383e285ce902c325e269766e77871e9dccacc548111e864ba2bfb27ca48fc69c7e22c5a0b1eee8e7c25e4763417ffe2c8fe
-  data.tar.gz: ed5f8ad72344e624e8a95d1e9a48078e0f6679d914f978974e0117b75bbc11ce2fbe08ece39360b20ce777ef5c5c333f37376f216272c1e6aa983eb18585fc92
+  metadata.gz: 6003aa038a7b476b8682aed9e32ba19ddbee6c124fe294c79b0371924527002f20c3ccdf45f71e2ee7360bef4e126d1ee0c15d93afd033df1166c20b5719187a
+  data.tar.gz: c0c462fada5b5d98f46298dc307d6000b56d537b8d7f80af1faba2206c682cebf02e588277ca5ea2bf6f4e21141928540c733f0f8851adc48b4ca1be8ede6f81

data/lib/t_ruby/ast_type_inferrer.rb

@@ -158,6 +158,8 @@ module TRuby
       type = case node
              when IR::Literal
                infer_literal(node)
+             when IR::InterpolatedString
+               "String" # Interpolated strings always produce String
              when IR::VariableRef
                infer_variable_ref(node, env)
              when IR::BinaryOp

data/lib/t_ruby/cache.rb

@@ -318,7 +318,7 @@ module TRuby
     def needs_compile?(file_path)
       return true unless File.exist?(file_path)
 
-      current_hash = file_hash(file_path)
+      current_hash = compute_file_hash(file_path)
       stored_hash = @file_hashes[file_path]
 
       return true if stored_hash.nil? || stored_hash != current_hash
@@ -333,7 +333,7 @@ module TRuby
       return @compiled_files[file_path] unless needs_compile?(file_path)
 
       result = @compiler.compile(file_path)
-      @file_hashes[file_path] = file_hash(file_path)
+      @file_hashes[file_path] = compute_file_hash(file_path)
       @compiled_files[file_path] = result
 
       result
@@ -365,9 +365,14 @@ module TRuby
       @cache.stats # Just accessing for potential cleanup
     end
 
+    # Update file hash after external compile (for watcher integration)
+    def update_file_hash(file_path)
+      @file_hashes[file_path] = compute_file_hash(file_path)
+    end
+
     private
 
-    def file_hash(file_path)
+    def compute_file_hash(file_path)
       return nil unless File.exist?(file_path)
 
       Digest::SHA256.hexdigest(File.read(file_path))
@@ -683,27 +688,52 @@ module TRuby
     end
 
     # Compile all with cross-file checking
+    # Returns diagnostics using unified Diagnostic format
     def compile_all_with_checking(file_paths)
       results = {}
-      errors = []
+      all_diagnostics = []
 
       # First pass: compile and register all files
       file_paths.each do |file_path|
-        results[file_path] = compile_with_ir(file_path)
-      rescue StandardError => e
-        errors << { file: file_path, error: e.message }
+        source = File.exist?(file_path) ? File.read(file_path) : nil
+
+        begin
+          results[file_path] = compile_with_ir(file_path)
+        rescue TypeCheckError => e
+          all_diagnostics << Diagnostic.from_type_check_error(e, file: file_path, source: source)
+        rescue ParseError => e
+          all_diagnostics << Diagnostic.from_parse_error(e, file: file_path, source: source)
+        rescue Scanner::ScanError => e
+          all_diagnostics << Diagnostic.from_scan_error(e, file: file_path, source: source)
+        rescue StandardError => e
+          all_diagnostics << Diagnostic.new(
+            code: "TR0001",
+            message: e.message,
+            file: file_path,
+            line: 1,
+            column: 1
+          )
+        end
       end
 
       # Second pass: cross-file type checking
       if @cross_file_checker
         check_result = @cross_file_checker.check_all
-        errors.concat(check_result[:errors])
+        check_result[:errors].each do |e|
+          all_diagnostics << Diagnostic.new(
+            code: "TR2002",
+            message: e[:message],
+            file: e[:file],
+            line: 1,
+            column: 1
+          )
+        end
       end
 
       {
         results: results,
-        errors: errors,
-        success: errors.empty?,
+        diagnostics: all_diagnostics,
+        success: all_diagnostics.empty?,
       }
     end
 

data/lib/t_ruby/cli.rb

@@ -135,7 +135,7 @@ module TRuby
           compiler:
             strictness: standard  # strict | standard | permissive
             generate_rbs: true
-            target_ruby: "3.0"
+            target_ruby: "#{RubyVersion.current.major}.#{RubyVersion.current.minor}"
             # experimental: []
             # checks:
             #   no_implicit_any: false
@@ -214,14 +214,19 @@ module TRuby
       config = Config.new(config_path)
       compiler = Compiler.new(config)
 
-      output_path = compiler.compile(input_file)
-      puts "Compiled: #{input_file} -> #{output_path}"
-    rescue TypeCheckError => e
-      puts "Type error: #{e.message}"
-      exit 1
-    rescue ArgumentError => e
-      puts "Error: #{e.message}"
-      exit 1
+      result = compiler.compile_with_diagnostics(input_file)
+
+      if result[:success]
+        puts "Compiled: #{input_file} -> #{result[:output_path]}"
+      else
+        formatter = DiagnosticFormatter.new(use_colors: $stdout.tty?)
+        result[:diagnostics].each do |diagnostic|
+          puts formatter.format(diagnostic)
+        end
+        puts
+        puts formatter.send(:format_summary, result[:diagnostics])
+        exit 1
+      end
     end
 
     # Extract config path from --config or -c flag

data/lib/t_ruby/code_emitter.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+module TRuby
+  # Version-specific code transformation strategies
+  #
+  # @example
+  #   emitter = CodeEmitter.for_version("4.0")
+  #   result = emitter.transform(source)
+  #
+  module CodeEmitter
+    # Factory method to get appropriate emitter for target Ruby version
+    #
+    # @param target_ruby [String] target Ruby version (e.g., "3.0", "4.0")
+    # @return [Base] appropriate emitter instance
+    def self.for_version(target_ruby)
+      version = RubyVersion.parse(target_ruby)
+
+      if version.numbered_parameters_raise_error?
+        Ruby40.new(version)
+      elsif version.supports_it_parameter?
+        Ruby34.new(version)
+      elsif version.supports_anonymous_block_forwarding?
+        Ruby31.new(version)
+      else
+        Ruby30.new(version)
+      end
+    end
+
+    # Base class for version-specific code emitters
+    class Base
+      attr_reader :version
+
+      def initialize(version)
+        @version = version
+      end
+
+      # Apply all transformations for this version
+      #
+      # @param source [String] source code to transform
+      # @return [String] transformed source code
+      def transform(source)
+        result = source.dup
+        result = transform_numbered_params(result)
+        transform_block_forwarding(result)
+      end
+
+      # Transform numbered block parameters (_1, _2, etc.)
+      # Default: no transformation
+      #
+      # @param source [String] source code
+      # @return [String] transformed source code
+      def transform_numbered_params(source)
+        source
+      end
+
+      # Transform block forwarding syntax
+      # Default: no transformation
+      #
+      # @param source [String] source code
+      # @return [String] transformed source code
+      def transform_block_forwarding(source)
+        source
+      end
+
+      # Check if this version supports the `it` implicit block parameter
+      #
+      # @return [Boolean]
+      def supports_it?
+        false
+      end
+
+      # Check if numbered parameters raise NameError in this version
+      #
+      # @return [Boolean]
+      def numbered_params_error?
+        false
+      end
+    end
+
+    # Ruby 3.0 emitter - baseline, no transformations
+    class Ruby30 < Base
+      # Ruby 3.0 uses standard syntax, no transformations needed
+    end
+
+    # Ruby 3.1+ emitter - supports anonymous block forwarding
+    class Ruby31 < Base
+      # Transform `def foo(&block) ... bar(&block)` to `def foo(&) ... bar(&)`
+      #
+      # Only transforms when the block parameter is ONLY used for forwarding,
+      # not when it's called directly (e.g., block.call)
+      def transform_block_forwarding(source)
+        result = source.dup
+
+        # Find method definitions with block parameters
+        # Pattern: def method_name(&block_name)
+        result.gsub!(/def\s+(\w+[?!=]?)\s*\(([^)]*?)&(\w+)\s*\)/) do |_match|
+          method_name = ::Regexp.last_match(1)
+          other_params = ::Regexp.last_match(2)
+          block_name = ::Regexp.last_match(3)
+
+          # Find the method body to check block usage
+          method_start = ::Regexp.last_match.begin(0)
+          remaining = result[method_start..]
+
+          # Check if block is only used for forwarding (not called directly)
+          if block_only_forwarded?(remaining, block_name)
+            "def #{method_name}(#{other_params}&)"
+          else
+            "def #{method_name}(#{other_params}&#{block_name})"
+          end
+        end
+
+        # Replace block forwarding calls with anonymous forwarding
+        # This is a simplified approach - in practice we'd need proper scope tracking
+        result.gsub!(/(\w+)\s*\(\s*&(\w+)\s*\)/) do |match|
+          call_name = ::Regexp.last_match(1)
+          ::Regexp.last_match(2)
+
+          # Check if this block name was converted to anonymous
+          if result.include?("def ") && result.include?("(&)")
+            "#{call_name}(&)"
+          else
+            match
+          end
+        end
+
+        result
+      end
+
+      private
+
+      # Check if a block parameter is only used for forwarding
+      def block_only_forwarded?(method_body, block_name)
+        # Simple heuristic: if block_name appears with .call or without &, it's not just forwarding
+        # Look for patterns like: block_name.call, block_name.(), yield
+
+        # Extract method body (until next def or end of class)
+        lines = method_body.lines
+        depth = 0
+        body_lines = []
+
+        lines.each do |line|
+          depth += 1 if line.match?(/\b(def|class|module|do|begin|case|if|unless|while|until)\b/)
+          depth -= 1 if line.match?(/\bend\b/)
+          body_lines << line
+          break if depth <= 0 && body_lines.length > 1
+        end
+
+        body = body_lines.join
+
+        # Check for direct block usage
+        return false if body.match?(/\b#{block_name}\s*\./)     # block.call, block.(), etc.
+        return false if body.match?(/\b#{block_name}\s*\[/)     # block[args]
+        return false if body.match?(/\byield\b/)                # yield instead of forwarding
+
+        # Only &block_name patterns - this is forwarding
+        true
+      end
+    end
+
+    # Ruby 3.4+ emitter - supports `it` implicit block parameter
+    class Ruby34 < Ruby31
+      def supports_it?
+        true
+      end
+
+      # Ruby 3.4 still supports _1 syntax, so no transformation needed by default
+      # Users can opt-in to using `it` style if they want
+    end
+
+    # Ruby 4.0+ emitter - _1 raises NameError, must use `it`
+    class Ruby40 < Ruby34
+      def numbered_params_error?
+        true
+      end
+
+      # Transform numbered parameters to appropriate syntax
+      #
+      # - Single _1 → it
+      # - Multiple (_1, _2) → explicit |k, v| params
+      def transform_numbered_params(source)
+        result = source.dup
+
+        # Simple approach: replace all _1 with it when it's the only numbered param in scope
+        # For complex cases with _2+, we'd need proper parsing
+        # For now, do a global replacement if _2 etc are not present
+        if result.match?(/\b_[2-9]\b/)
+          # Has multiple numbered params - need to convert to explicit params
+          # This is a complex case that requires proper block parsing
+          transform_multi_numbered_params(result)
+        else
+          # Only _1 is used - simple replacement
+          result.gsub(/\b_1\b/, "it")
+        end
+      end
+
+      private
+
+      def transform_multi_numbered_params(source)
+        result = source.dup
+
+        # Find blocks and transform them
+        # Use a recursive approach with placeholder replacement
+
+        # Replace innermost blocks first
+        loop do
+          changed = false
+          result = result.gsub(/\{([^{}]*)\}/) do |block|
+            content = ::Regexp.last_match(1)
+            max_param = find_max_numbered_param(content)
+
+            if max_param > 1
+              # Multiple params - convert to explicit
+              param_names = generate_param_names(max_param)
+              new_content = content.dup
+              (1..max_param).each do |i|
+                new_content.gsub!(/\b_#{i}\b/, param_names[i - 1])
+              end
+              changed = true
+              "{ |#{param_names.join(", ")}| #{new_content.strip} }"
+            elsif max_param == 1
+              # Single _1 - convert to it
+              changed = true
+              "{ #{content.gsub(/\b_1\b/, "it").strip} }"
+            else
+              block
+            end
+          end
+          break unless changed
+        end
+
+        result
+      end
+
+      def find_max_numbered_param(content)
+        max = 0
+        content.scan(/\b_(\d+)\b/) do |match|
+          num = match[0].to_i
+          max = num if num > max
+        end
+        max
+      end
+
+      def generate_param_names(count)
+        # Generate simple parameter names: a, b, c, ... or k, v for 2
+        if count == 2
+          %w[k v]
+        else
+          ("a".."z").take(count)
+        end
+      end
+    end
+  end
+end

data/lib/t_ruby/compiler.rb

@@ -76,6 +76,161 @@ module TRuby
       output_path
     end
 
+    # Compile a file and return result with diagnostics
+    # This is the unified compilation interface for CLI and Watcher
+    # @param input_path [String] Path to the input file
+    # @return [Hash] Result with :success, :output_path, :diagnostics keys
+    def compile_with_diagnostics(input_path)
+      source = File.exist?(input_path) ? File.read(input_path) : nil
+      all_diagnostics = []
+
+      # Run analyze first to get all diagnostics (colon spacing, etc.)
+      if source
+        all_diagnostics = analyze(source, file: input_path)
+      end
+
+      begin
+        output_path = compile(input_path)
+        # Compilation succeeded, but we may still have diagnostics from analyze
+        {
+          success: all_diagnostics.empty?,
+          output_path: all_diagnostics.empty? ? output_path : nil,
+          diagnostics: all_diagnostics,
+        }
+      rescue TypeCheckError => e
+        # Skip if already reported by analyze (same message and location)
+        new_diag = Diagnostic.from_type_check_error(e, file: input_path, source: source)
+        unless all_diagnostics.any? { |d| d.message == new_diag.message && d.line == new_diag.line }
+          all_diagnostics << new_diag
+        end
+        {
+          success: false,
+          output_path: nil,
+          diagnostics: all_diagnostics,
+        }
+      rescue ParseError => e
+        new_diag = Diagnostic.from_parse_error(e, file: input_path, source: source)
+        unless all_diagnostics.any? { |d| d.message == new_diag.message && d.line == new_diag.line }
+          all_diagnostics << new_diag
+        end
+        {
+          success: false,
+          output_path: nil,
+          diagnostics: all_diagnostics,
+        }
+      rescue Scanner::ScanError => e
+        new_diag = Diagnostic.from_scan_error(e, file: input_path, source: source)
+        unless all_diagnostics.any? { |d| d.message == new_diag.message && d.line == new_diag.line }
+          all_diagnostics << new_diag
+        end
+        {
+          success: false,
+          output_path: nil,
+          diagnostics: all_diagnostics,
+        }
+      rescue ArgumentError => e
+        all_diagnostics << Diagnostic.new(
+          code: "TR0001",
+          message: e.message,
+          file: input_path,
+          severity: Diagnostic::SEVERITY_ERROR
+        )
+        {
+          success: false,
+          output_path: nil,
+          diagnostics: all_diagnostics,
+        }
+      end
+    end
+
+    # Analyze source code without compiling - returns diagnostics only
+    # This is the unified analysis interface for LSP and other tools
+    # @param source [String] T-Ruby source code
+    # @param file [String] File path for error reporting (optional)
+    # @return [Array<Diagnostic>] Array of diagnostic objects
+    def analyze(source, file: "<source>")
+      diagnostics = []
+      source_lines = source.split("\n")
+
+      # Run ErrorHandler checks (syntax validation, duplicate definitions, etc.)
+      error_handler = ErrorHandler.new(source)
+      errors = error_handler.check
+      errors.each do |error|
+        # Parse line number from "Line N: message" format
+        next unless error =~ /^Line (\d+):\s*(.+)$/
+
+        line_num = Regexp.last_match(1).to_i
+        message = Regexp.last_match(2)
+        source_line = source_lines[line_num - 1] if line_num.positive?
+        diagnostics << Diagnostic.new(
+          code: "TR1002",
+          message: message,
+          file: file,
+          line: line_num,
+          column: 1,
+          source_line: source_line,
+          severity: Diagnostic::SEVERITY_ERROR
+        )
+      end
+
+      # Run TokenDeclarationParser for colon spacing and declaration syntax validation
+      begin
+        scanner = Scanner.new(source)
+        tokens = scanner.scan_all
+        decl_parser = ParserCombinator::TokenDeclarationParser.new
+        decl_parser.parse_program(tokens)
+
+        if decl_parser.has_errors?
+          decl_parser.errors.each do |err|
+            source_line = source_lines[err.line - 1] if err.line.positive? && err.line <= source_lines.length
+            diagnostics << Diagnostic.new(
+              code: "TR1003",
+              message: err.message,
+              file: file,
+              line: err.line,
+              column: err.column,
+              source_line: source_line,
+              severity: Diagnostic::SEVERITY_ERROR
+            )
+          end
+        end
+      rescue Scanner::ScanError
+        # Scanner errors will be caught below in the main parse section
+      rescue StandardError
+        # Ignore TokenDeclarationParser errors for now - regex parser is authoritative
+      end
+
+      begin
+        # Parse source with regex-based parser for IR generation
+        parser = Parser.new(source)
+        parser.parse
+
+        # Run type checking if enabled and IR is available
+        if type_check? && parser.ir_program
+          begin
+            check_types(parser.ir_program, file)
+          rescue TypeCheckError => e
+            diagnostics << Diagnostic.from_type_check_error(e, file: file, source: source)
+          end
+        end
+      rescue ParseError => e
+        diagnostics << Diagnostic.from_parse_error(e, file: file, source: source)
+      rescue Scanner::ScanError => e
+        diagnostics << Diagnostic.from_scan_error(e, file: file, source: source)
+      rescue StandardError => e
+        diagnostics << Diagnostic.new(
+          code: "TR0001",
+          message: e.message,
+          file: file,
+          line: 1,
+          column: 1,
+          severity: Diagnostic::SEVERITY_ERROR
+        )
+      end
+
+      diagnostics
+    end
+
     # Compile T-Ruby source code from a string (useful for WASM/playground)
     # @param source [String] T-Ruby source code
     # @param options [Hash] Options for compilation
@@ -319,6 +474,19 @@ module TRuby
       # Subtype relationships
       return true if subtype_of?(inferred, declared)
 
+      # Handle generic types (e.g., Array[untyped] is compatible with Array[String])
+      if inferred.include?("[") && declared.include?("[")
+        inferred_base = inferred.split("[").first
+        declared_base = declared.split("[").first
+        if inferred_base == declared_base
+          # Extract type arguments
+          inferred_args = inferred[/\[(.+)\]/, 1]
+          declared_args = declared[/\[(.+)\]/, 1]
+          # untyped type argument is compatible with any type argument
+          return true if inferred_args == "untyped" || declared_args == "untyped"
+        end
+      end
+
       # Handle union types in declared
       if declared.include?("|")
         declared_types = declared.split("|").map(&:strip)
@@ -380,8 +548,8 @@ module TRuby
         ir_program = result[:program]
       end
 
-      # Generate Ruby code using IR-aware generator
-      generator = IRCodeGenerator.new
+      # Generate Ruby code using IR-aware generator with target Ruby version
+      generator = IRCodeGenerator.new(target_ruby: @config.target_ruby)
       generator.generate_with_source(ir_program, source)
     end
 
@@ -434,8 +602,12 @@ module TRuby
 
   # IR-aware code generator for source-preserving transformation
   class IRCodeGenerator
-    def initialize
+    attr_reader :emitter
+
+    # @param target_ruby [String] target Ruby version (e.g., "3.0", "4.0")
+    def initialize(target_ruby: "3.0")
       @output = []
+      @emitter = CodeEmitter.for_version(target_ruby)
     end
 
     # Generate Ruby code from IR program
@@ -471,6 +643,9 @@ module TRuby
       # Remove return type annotations
       result = erase_return_types(result)
 
+      # Apply version-specific transformations
+      result = @emitter.transform(result)
+
       # Clean up extra blank lines
       result.gsub(/\n{3,}/, "\n\n")
     end
@@ -545,6 +720,14 @@ module TRuby
       param = param.strip
       return nil if param.empty?
 
+      # 0. 블록 파라미터: &name: Type -> &name
+      if param.start_with?("&")
+        match = param.match(/^&(\w+)(?::\s*.+)?$/)
+        return "&#{match[1]}" if match
+
+        return param
+      end
+
       # 1. 더블 스플랫: **name: Type -> **name
       if param.start_with?("**")
         match = param.match(/^\*\*(\w+)(?::\s*.+)?$/)

data/lib/t_ruby/config.rb

@@ -25,7 +25,7 @@ module TRuby
         "strictness" => "standard",
         "generate_rbs" => true,
         "type_check" => true,
-        "target_ruby" => "3.0",
+        "target_ruby" => nil, # Auto-detect from current Ruby version
         "experimental" => [],
         "checks" => {
           "no_implicit_any" => false,
@@ -97,9 +97,24 @@ module TRuby
     end
 
     # Get target Ruby version
-    # @return [String] target Ruby version (e.g., "3.0", "3.2")
+    # If not specified in config, auto-detects from current Ruby environment
+    # @return [String] target Ruby version (e.g., "3.0", "3.2", "4.0")
+    # @raise [UnsupportedRubyVersionError] if detected version is not supported
     def target_ruby
-      (@compiler["target_ruby"] || "3.0").to_s
+      configured = @compiler["target_ruby"]
+      if configured
+        RubyVersion.parse(configured).validate!
+        configured.to_s
+      else
+        version = RubyVersion.current.validate!
+        "#{version.major}.#{version.minor}"
+      end
+    end
+
+    # Get target Ruby version as RubyVersion object
+    # @return [RubyVersion] target Ruby version object
+    def target_ruby_version
+      RubyVersion.parse(target_ruby)
     end
 
     # Get list of enabled experimental features