t-ruby 0.0.40 → 0.0.42

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54f0b9008d5a42a8cbf851eac8a0eb540670c3c87018dd87182baf6ab30c7d55
-  data.tar.gz: 42929dd91ae55ea84e75fd6978298deea2fec1d3517a801bde06af6f70865557
+  metadata.gz: 75019794a577853cf5a7e704febef3868a1ddd06776e43f50dc684d7dde87e3c
+  data.tar.gz: 89a255f7e7b68e2becd6314be09470424d5f418324c40bcc77a7311e6006d9f0
 SHA512:
-  metadata.gz: 20916cbdb9a4d62bd9208c8496df8e8f425885c600d5caa9ef0d5a545c4d52a62fa66d05157bfc89a0c57328658f6ecb08889336352e76b4cfb757518365f50b
-  data.tar.gz: b6125521d066808e825747418d794ca6adb94503e7d89b61fe5a9bb009e2c2fcc49952b0ea3fd12f5c0bb51de9d20de0ff3a7b4f0ab37358d0616010e1f9ca55
+  metadata.gz: 4000a38df6e83591a15f453af3b4d5f759b1af8e869478737c1d7711e34c7e1d65c89df34e56a6575d41e2f120e951970fde1ac444bf24d73c1167a24de875c4
+  data.tar.gz: 9273b4bf7d8a9af3ccbe0fa0d93914b13c9ce09f464902a4974749780871516c8fbaeb33a60d1dca754914dde09e498148ec080ff31fef3b11a0a88d96642eee

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

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

@@ -380,8 +380,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 +434,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 +475,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
@@ -505,6 +512,7 @@ module TRuby
       params = []
       current = ""
       depth = 0
+      brace_depth = 0
 
       params_str.each_char do |char|
         case char
@@ -514,9 +522,16 @@ module TRuby
         when ">", "]", ")"
           depth -= 1
           current += char
+        when "{"
+          brace_depth += 1
+          current += char
+        when "}"
+          brace_depth -= 1
+          current += char
         when ","
-          if depth.zero?
-            params << clean_param(current.strip)
+          if depth.zero? && brace_depth.zero?
+            cleaned = clean_param(current.strip)
+            params.concat(Array(cleaned)) if cleaned
             current = ""
           else
             current += char
@@ -526,12 +541,47 @@ module TRuby
         end
       end
 
-      params << clean_param(current.strip) unless current.empty?
+      cleaned = clean_param(current.strip) unless current.empty?
+      params.concat(Array(cleaned)) if cleaned
       params.join(", ")
     end
 
     # Clean a single parameter (remove type annotation, preserve default value)
+    # Returns String or Array of Strings (for keyword args group)
     def clean_param(param)
+      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*.+)?$/)
+        return "**#{match[1]}" if match
+
+        return param
+      end
+
+      # 2. 키워드 인자 그룹: { ... } 또는 { ... }: InterfaceName
+      if param.start_with?("{")
+        return clean_keyword_args_group(param)
+      end
+
+      # 3. Hash 리터럴: name: { ... } -> name
+      if param.match?(/^\w+:\s*\{/)
+        match = param.match(/^(\w+):\s*\{.+\}(?::\s*\w+)?$/)
+        return match[1] if match
+
+        return param
+      end
+
+      # 4. 일반 파라미터: name: Type = value -> name = value 또는 name: Type -> name
       # Match: name: Type = value (with default value)
       if (match = param.match(/^(#{TRuby::IDENTIFIER_CHAR}+)\s*:\s*.+?\s*(=\s*.+)$/))
         "#{match[1]} #{match[2]}"
@@ -543,15 +593,83 @@ module TRuby
       end
     end
 
+    # 키워드 인자 그룹을 Ruby 키워드 인자로 변환
+    # { name: String, age: Integer = 0 } -> name:, age: 0
+    # { name:, age: 0 }: UserParams -> name:, age: 0
+    def clean_keyword_args_group(param)
+      # { ... }: InterfaceName 또는 { ... } 형태 파싱
+      interface_match = param.match(/^\{(.+)\}\s*:\s*\w+\s*$/)
+      inline_match = param.match(/^\{(.+)\}\s*$/) unless interface_match
+
+      inner_content = if interface_match
+                        interface_match[1]
+                      elsif inline_match
+                        inline_match[1]
+                      else
+                        return param
+                      end
+
+      # 내부 파라미터 분리
+      parts = split_nested_content(inner_content)
+      keyword_params = []
+
+      parts.each do |part|
+        part = part.strip
+        next if part.empty?
+
+        if interface_match
+          # interface 참조: name: default_value 또는 name:
+          if (match = part.match(/^(\w+):\s*(.*)$/))
+            name = match[1]
+            default_value = match[2].strip
+            keyword_params << if default_value.empty?
+                                "#{name}:"
+                              else
+                                "#{name}: #{default_value}"
+                              end
+          end
+        elsif (match = part.match(/^(\w+):\s*(.+)$/))
+          # 인라인 타입: name: Type = default 또는 name: Type
+          name = match[1]
+          type_and_default = match[2].strip
+
+          # Type = default 분리
+          default_value = extract_default_value(type_and_default)
+          keyword_params << if default_value
+                              "#{name}: #{default_value}"
+                            else
+                              "#{name}:"
+                            end
+        end
+      end
+
+      keyword_params
+    end
+
+    # 중첩된 내용을 콤마로 분리
+    def split_nested_content(content)
+      StringUtils.split_by_comma(content)
+    end
+
+    # 타입과 기본값에서 기본값만 추출
+    def extract_default_value(type_and_default)
+      StringUtils.extract_default_value(type_and_default)
+    end
+
     # Erase return type annotations
     def erase_return_types(source)
       result = source.dup
 
-      # Remove return type: ): Type or ): Type<Foo> etc.
+      # Remove return type after parentheses: ): Type or ): Type<Foo> etc.
       result.gsub!(/\)\s*:\s*[^\n]+?(?=\s*$)/m) do |_match|
         ")"
       end
 
+      # Remove return type for methods without parentheses: def method_name: Type
+      result.gsub!(/^(\s*#{TRuby::VISIBILITY_PATTERN}def\s+#{TRuby::METHOD_NAME_PATTERN})\s*:\s*[^\n]+?(?=\s*$)/m) do |_match|
+        ::Regexp.last_match(1)
+      end
+
       result
     end
   end

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

data/lib/t_ruby/ir.rb

@@ -147,15 +147,19 @@ module TRuby
 
     # Method parameter
     class Parameter < Node
-      attr_accessor :name, :type_annotation, :default_value, :kind
+      attr_accessor :name, :type_annotation, :default_value, :kind, :interface_ref
 
-      # kind: :required, :optional, :rest, :keyrest, :block
-      def initialize(name:, type_annotation: nil, default_value: nil, kind: :required, **opts)
+      # kind: :required, :optional, :rest, :keyrest, :block, :keyword
+      # :keyword - 키워드 인자 (구조분해): { name: String } → def foo(name:)
+      # :keyrest - 더블 스플랫: **opts: Type → def foo(**opts)
+      # interface_ref - interface 참조 타입 (예: }: UserParams 부분)
+      def initialize(name:, type_annotation: nil, default_value: nil, kind: :required, interface_ref: nil, **opts)
         super(**opts)
         @name = name
         @type_annotation = type_annotation
         @default_value = default_value
         @kind = kind
+        @interface_ref = interface_ref
       end
     end
 

data/lib/t_ruby/parser.rb

@@ -244,18 +244,36 @@ module TRuby
       param_list = split_params(params_str)
 
       param_list.each do |param|
-        param_info = parse_single_parameter(param)
-        parameters << param_info if param_info
+        param = param.strip
+
+        # 1. 더블 스플랫: **name: Type
+        if param.start_with?("**")
+          param_info = parse_double_splat_parameter(param)
+          parameters << param_info if param_info
+        # 2. 키워드 인자 그룹: { ... } 또는 { ... }: InterfaceName
+        elsif param.start_with?("{")
+          keyword_params = parse_keyword_args_group(param)
+          parameters.concat(keyword_params) if keyword_params
+        # 3. Hash 리터럴: name: { ... }
+        elsif param.match?(/^\w+:\s*\{/)
+          param_info = parse_hash_literal_parameter(param)
+          parameters << param_info if param_info
+        # 4. 일반 위치 인자: name: Type 또는 name: Type = default
+        else
+          param_info = parse_single_parameter(param)
+          parameters << param_info if param_info
+        end
       end
 
       parameters
     end
 
     def split_params(params_str)
-      # Handle nested generics like Array<Map<String, Int>>
+      # Handle nested generics, braces, brackets
       result = []
       current = ""
       depth = 0
+      brace_depth = 0
 
       params_str.each_char do |char|
         case char
@@ -265,8 +283,14 @@ module TRuby
         when ">", "]", ")"
           depth -= 1
           current += char
+        when "{"
+          brace_depth += 1
+          current += char
+        when "}"
+          brace_depth -= 1
+          current += char
         when ","
-          if depth.zero?
+          if depth.zero? && brace_depth.zero?
             result << current.strip
             current = ""
           else
@@ -281,8 +305,10 @@ module TRuby
       result
     end
 
-    def parse_single_parameter(param)
-      match = param.match(/^(\w+)(?::\s*(.+?))?$/)
+    # 더블 스플랫 파라미터 파싱: **opts: Type
+    def parse_double_splat_parameter(param)
+      # **name: Type
+      match = param.match(/^\*\*(\w+)(?::\s*(.+?))?$/)
       return nil unless match
 
       param_name = match[1]
@@ -291,6 +317,155 @@ module TRuby
       result = {
         name: param_name,
         type: type_str,
+        kind: :keyrest,
+      }
+
+      if type_str
+        type_result = @type_parser.parse(type_str)
+        result[:ir_type] = type_result[:type] if type_result[:success]
+      end
+
+      result
+    end
+
+    # 키워드 인자 그룹 파싱: { name: String, age: Integer = 0 } 또는 { name:, age: 0 }: InterfaceName
+    def parse_keyword_args_group(param)
+      # { ... }: InterfaceName 형태 확인
+      # 또는 { ... } 만 있는 형태 (인라인 타입)
+      interface_match = param.match(/^\{(.+)\}\s*:\s*(\w+)\s*$/)
+      inline_match = param.match(/^\{(.+)\}\s*$/) unless interface_match
+
+      if interface_match
+        inner_content = interface_match[1]
+        interface_name = interface_match[2]
+        parse_keyword_args_with_interface(inner_content, interface_name)
+      elsif inline_match
+        inner_content = inline_match[1]
+        parse_keyword_args_inline(inner_content)
+      end
+    end
+
+    # interface 참조 키워드 인자 파싱: { name:, age: 0 }: UserParams
+    def parse_keyword_args_with_interface(inner_content, interface_name)
+      parameters = []
+      parts = split_keyword_args(inner_content)
+
+      parts.each do |part|
+        part = part.strip
+        next if part.empty?
+
+        # name: default_value 또는 name: 형태
+        next unless part.match?(/^(\w+):\s*(.*)$/)
+
+        match = part.match(/^(\w+):\s*(.*)$/)
+        param_name = match[1]
+        default_value = match[2].strip
+        default_value = nil if default_value.empty?
+
+        parameters << {
+          name: param_name,
+          type: nil, # interface에서 타입을 가져옴
+          default_value: default_value,
+          kind: :keyword,
+          interface_ref: interface_name,
+        }
+      end
+
+      parameters
+    end
+
+    # 인라인 타입 키워드 인자 파싱: { name: String, age: Integer = 0 }
+    def parse_keyword_args_inline(inner_content)
+      parameters = []
+      parts = split_keyword_args(inner_content)
+
+      parts.each do |part|
+        part = part.strip
+        next if part.empty?
+
+        # name: Type = default 또는 name: Type 형태
+        next unless part.match?(/^(\w+):\s*(.+)$/)
+
+        match = part.match(/^(\w+):\s*(.+)$/)
+        param_name = match[1]
+        type_and_default = match[2].strip
+
+        # Type = default 분리
+        type_str, default_value = split_type_and_default(type_and_default)
+
+        result = {
+          name: param_name,
+          type: type_str,
+          default_value: default_value,
+          kind: :keyword,
+        }
+
+        if type_str
+          type_result = @type_parser.parse(type_str)
+          result[:ir_type] = type_result[:type] if type_result[:success]
+        end
+
+        parameters << result
+      end
+
+      parameters
+    end
+
+    # 키워드 인자 내부를 콤마로 분리 (중첩된 제네릭/배열/해시 고려)
+    def split_keyword_args(content)
+      StringUtils.split_by_comma(content)
+    end
+
+    # 타입과 기본값 분리: "String = 0" -> ["String", "0"]
+    def split_type_and_default(type_and_default)
+      StringUtils.split_type_and_default(type_and_default)
+    end
+
+    # Hash 리터럴 파라미터 파싱: config: { host: String, port: Integer }
+    def parse_hash_literal_parameter(param)
+      # name: { ... } 또는 name: { ... }: InterfaceName
+      match = param.match(/^(\w+):\s*(\{.+\})(?::\s*(\w+))?$/)
+      return nil unless match
+
+      param_name = match[1]
+      hash_type = match[2]
+      interface_name = match[3]
+
+      result = {
+        name: param_name,
+        type: interface_name || hash_type,
+        kind: :required,
+        hash_type_def: hash_type, # 원본 해시 타입 정의 저장
+      }
+
+      result[:interface_ref] = interface_name if interface_name
+
+      result
+    end
+
+    def parse_single_parameter(param)
+      # name: Type = default 또는 name: Type 또는 name
+      # 기본값이 있는 경우 먼저 처리
+      type_str = nil
+      default_value = nil
+
+      if param.include?(":")
+        match = param.match(/^(\w+):\s*(.+)$/)
+        return nil unless match
+
+        param_name = match[1]
+        type_and_default = match[2].strip
+        type_str, default_value = split_type_and_default(type_and_default)
+      else
+        # 타입 없이 이름만 있는 경우
+        param_name = param.strip
+      end
+
+      result = {
+        name: param_name,
+        type: type_str,
+        default_value: default_value,
+        kind: default_value ? :optional : :required,
       }
 
       # Parse type with combinator

data/lib/t_ruby/ruby_version.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module TRuby
+  # Error raised when an unsupported Ruby version is detected
+  class UnsupportedRubyVersionError < StandardError; end
+
+  # Value object representing a Ruby version with comparison and feature detection
+  #
+  # @example
+  #   version = RubyVersion.parse("3.4")
+  #   version.supports_it_parameter? # => true
+  #   version >= RubyVersion.parse("3.0") # => true
+  #
+  class RubyVersion
+    include Comparable
+
+    # Supported version range
+    MIN_VERSION = [3, 0].freeze
+    MAX_MAJOR = 4
+
+    # Version string pattern: major.minor or major.minor.patch
+    VERSION_REGEX = /\A(\d+)\.(\d+)(?:\.(\d+))?\z/
+
+    attr_reader :major, :minor, :patch
+
+    # @param major [Integer] major version number
+    # @param minor [Integer] minor version number
+    # @param patch [Integer] patch version number (default: 0)
+    def initialize(major, minor, patch = 0)
+      @major = major
+      @minor = minor
+      @patch = patch
+    end
+
+    # Parse a version string into a RubyVersion object
+    #
+    # @param version_string [String, Numeric] version string (e.g., "3.4", "3.4.1")
+    # @return [RubyVersion] parsed version object
+    # @raise [ArgumentError] if version format is invalid
+    def self.parse(version_string)
+      str = version_string.to_s
+      match = VERSION_REGEX.match(str)
+
+      raise ArgumentError, "Invalid version: #{version_string}" unless match
+
+      new(match[1].to_i, match[2].to_i, (match[3] || 0).to_i)
+    end
+
+    # Get the current Ruby version from the environment
+    #
+    # @return [RubyVersion] current Ruby version
+    def self.current
+      parse(RUBY_VERSION)
+    end
+
+    # Compare two versions
+    #
+    # @param other [RubyVersion] version to compare with
+    # @return [Integer] -1, 0, or 1
+    def <=>(other)
+      [major, minor, patch] <=> [other.major, other.minor, other.patch]
+    end
+
+    # Convert to string representation
+    #
+    # @return [String] version string (e.g., "3.4" or "3.4.1")
+    def to_s
+      patch.zero? ? "#{major}.#{minor}" : "#{major}.#{minor}.#{patch}"
+    end
+
+    # Check if this version is within the supported range (3.0 ~ 4.x)
+    #
+    # @return [Boolean] true if version is supported
+    def supported?
+      self >= self.class.parse("#{MIN_VERSION[0]}.#{MIN_VERSION[1]}") && major <= MAX_MAJOR
+    end
+
+    # Validate that this version is supported, raising an error if not
+    #
+    # @return [RubyVersion] self if valid
+    # @raise [UnsupportedRubyVersionError] if version is not supported
+    def validate!
+      unless supported?
+        raise UnsupportedRubyVersionError,
+              "Ruby #{self}는 지원되지 않습니다. 지원 범위: #{MIN_VERSION.join(".")} ~ #{MAX_MAJOR}.x"
+      end
+
+      self
+    end
+
+    # Check if this version supports the `it` implicit block parameter (Ruby 3.4+)
+    #
+    # @return [Boolean] true if `it` parameter is supported
+    def supports_it_parameter?
+      self >= self.class.parse("3.4")
+    end
+
+    # Check if this version supports anonymous block forwarding `def foo(&) ... end` (Ruby 3.1+)
+    #
+    # @return [Boolean] true if anonymous block forwarding is supported
+    def supports_anonymous_block_forwarding?
+      self >= self.class.parse("3.1")
+    end
+
+    # Check if numbered parameters (_1, _2, etc.) raise NameError (Ruby 4.0+)
+    #
+    # @return [Boolean] true if numbered parameters cause errors
+    def numbered_parameters_raise_error?
+      self >= self.class.parse("4.0")
+    end
+  end
+end

data/lib/t_ruby/string_utils.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module TRuby
+  # 문자열 파싱을 위한 공통 유틸리티 모듈
+  # 파서와 컴파일러에서 공유하는 중첩 괄호 처리 로직
+  module StringUtils
+    module_function
+
+    # 중첩된 괄호를 고려하여 콤마로 문자열 분리
+    # @param content [String] 분리할 문자열
+    # @return [Array<String>] 분리된 문자열 배열
+    def split_by_comma(content)
+      result = []
+      current = ""
+      depth = 0
+
+      content.each_char do |char|
+        case char
+        when "<", "[", "(", "{"
+          depth += 1
+          current += char
+        when ">", "]", ")", "}"
+          depth -= 1
+          current += char
+        when ","
+          if depth.zero?
+            result << current.strip
+            current = ""
+          else
+            current += char
+          end
+        else
+          current += char
+        end
+      end
+
+      result << current.strip unless current.empty?
+      result
+    end
+
+    # 타입과 기본값 분리: "String = 0" -> ["String", "0"]
+    # 중첩된 괄호 내부의 = 는 무시
+    # @param type_and_default [String] "Type = default" 형태의 문자열
+    # @return [Array] [type_str, default_value] 또는 [type_str, nil]
+    def split_type_and_default(type_and_default)
+      depth = 0
+      equals_pos = nil
+
+      type_and_default.each_char.with_index do |char, i|
+        case char
+        when "<", "[", "(", "{"
+          depth += 1
+        when ">", "]", ")", "}"
+          depth -= 1
+        when "="
+          if depth.zero?
+            equals_pos = i
+            break
+          end
+        end
+      end
+
+      if equals_pos
+        type_str = type_and_default[0...equals_pos].strip
+        default_value = type_and_default[(equals_pos + 1)..].strip
+        [type_str, default_value]
+      else
+        [type_and_default, nil]
+      end
+    end
+
+    # 기본값만 추출 (타입은 버림)
+    # @param type_and_default [String] "Type = default" 형태의 문자열
+    # @return [String, nil] 기본값 또는 nil
+    def extract_default_value(type_and_default)
+      _, default_value = split_type_and_default(type_and_default)
+      default_value
+    end
+  end
+end

data/lib/t_ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TRuby
-  VERSION = "0.0.40"
+  VERSION = "0.0.42"
 end

data/lib/t_ruby/watcher.rb

@@ -1,6 +1,13 @@
 # frozen_string_literal: true
 
-require "listen"
+# listen gem is optional - only required for watch mode
+# This allows T-Ruby core functionality to work on Ruby 4.0+ where listen/ffi may not be available
+begin
+  require "listen"
+  LISTEN_AVAILABLE = true
+rescue LoadError
+  LISTEN_AVAILABLE = false
+end
 
 module TRuby
   class Watcher
@@ -52,6 +59,14 @@ module TRuby
     end
 
     def watch
+      unless LISTEN_AVAILABLE
+        puts colorize(:red, "Error: Watch mode requires the 'listen' gem.")
+        puts colorize(:yellow, "The 'listen' gem is not available (possibly due to Ruby 4.0+ ffi compatibility).")
+        puts colorize(:dim, "Install with: gem install listen")
+        puts colorize(:dim, "Or run without watch mode: trc")
+        exit 1
+      end
+
       print_start_message
 
       # Initial compilation

data/lib/t_ruby.rb

@@ -2,9 +2,12 @@
 
 require_relative "t_ruby/version"
 require_relative "t_ruby/version_checker"
+require_relative "t_ruby/ruby_version"
+require_relative "t_ruby/code_emitter"
 require_relative "t_ruby/config"
 
 # Core infrastructure (must be loaded first)
+require_relative "t_ruby/string_utils"
 require_relative "t_ruby/ir"
 require_relative "t_ruby/parser_combinator"
 require_relative "t_ruby/smt_solver"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: t-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.40
+  version: 0.0.42
 platform: ruby
 authors:
 - Y. Fred Kim
@@ -10,19 +10,19 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: listen
+  name: benchmark
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.8'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.8'
+        version: '0'
 description: t-ruby compiles .trb files with type annotations to executable Ruby (.rb)
   and optional type signature files (.rbs)
 email:
@@ -42,6 +42,7 @@ files:
 - lib/t_ruby/bundler_integration.rb
 - lib/t_ruby/cache.rb
 - lib/t_ruby/cli.rb
+- lib/t_ruby/code_emitter.rb
 - lib/t_ruby/compiler.rb
 - lib/t_ruby/config.rb
 - lib/t_ruby/constraint_checker.rb
@@ -59,8 +60,10 @@ files:
 - lib/t_ruby/package_manager.rb
 - lib/t_ruby/parser.rb
 - lib/t_ruby/parser_combinator.rb
+- lib/t_ruby/ruby_version.rb
 - lib/t_ruby/runtime_validator.rb
 - lib/t_ruby/smt_solver.rb
+- lib/t_ruby/string_utils.rb
 - lib/t_ruby/type_alias_registry.rb
 - lib/t_ruby/type_checker.rb
 - lib/t_ruby/type_env.rb