t-ruby 0.0.39 → 0.0.41

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64bc7ea0ab44e83d6580d07227fee508ae3b5e53bc0e6b19b8164857eaf31376
-  data.tar.gz: 01da8585df97030974563634d8212058a3d3325ca9bc05188ae12ccf1cdc6770
+  metadata.gz: 6a7c7a93e1498a150b541ea7f7838c08435a33ead72774b7e4c0b8ead951e9d3
+  data.tar.gz: 1fbfb9ea6b276e130ef04891f39d691e362d5352dc4f0209b00009105f13c3a0
 SHA512:
-  metadata.gz: b0bf9cd9518368e5ef256dd1851285fbbb78404b16c837346ecb286bfde37d2b8f8f5738782629efb5507fb7419eaea197726ae85f1ccb9481c09abc26d80a7f
-  data.tar.gz: 67de07897cec9ef86c5df0798c4f2d44e1d54da0d8bfe799386eb544c28a4c0d5595f17dcc0c0bbc4236a44c17e76f1283fc75a9cd4452cee40f34daa86ef609
+  metadata.gz: 82cbc96204194f51b65f484aeda25383e285ce902c325e269766e77871e9dccacc548111e864ba2bfb27ca48fc69c7e22c5a0b1eee8e7c25e4763417ffe2c8fe
+  data.tar.gz: ed5f8ad72344e624e8a95d1e9a48078e0f6679d914f978974e0117b75bbc11ce2fbe08ece39360b20ce777ef5c5c333f37376f216272c1e6aa983eb18585fc92

data/lib/t_ruby/compiler.rb

@@ -7,16 +7,17 @@ module TRuby
   # \p{L} matches any Unicode letter, \p{N} matches any Unicode number
   IDENTIFIER_CHAR = '[\p{L}\p{N}_]'
   METHOD_NAME_PATTERN = "#{IDENTIFIER_CHAR}+[?!]?".freeze
+  # Visibility modifiers for method definitions
+  VISIBILITY_PATTERN = '(?:(?:private|protected|public)\s+)?'
 
   class Compiler
-    attr_reader :declaration_loader, :use_ir, :optimizer
+    attr_reader :declaration_loader, :optimizer
 
-    def initialize(config = nil, use_ir: true, optimize: true)
+    def initialize(config = nil, optimize: true)
       @config = config || Config.new
-      @use_ir = use_ir
       @optimize = optimize
       @declaration_loader = DeclarationLoader.new
-      @optimizer = IR::Optimizer.new if use_ir && optimize
+      @optimizer = IR::Optimizer.new if optimize
       @type_inferrer = ASTTypeInferrer.new if type_check?
       setup_declaration_paths if @config
     end
@@ -42,16 +43,16 @@ module TRuby
       source = File.read(input_path)
 
       # Parse with IR support
-      parser = Parser.new(source, use_combinator: @use_ir)
-      parse_result = parser.parse
+      parser = Parser.new(source)
+      parser.parse
 
       # Run type checking if enabled
-      if type_check? && @use_ir && parser.ir_program
+      if type_check? && parser.ir_program
         check_types(parser.ir_program, input_path)
       end
 
       # Transform source to Ruby code
-      output = @use_ir ? transform_with_ir(source, parser) : transform_legacy(source, parse_result)
+      output = transform_with_ir(source, parser)
 
       # Compute output path (respects preserve_structure setting)
       output_path = compute_output_path(input_path, @config.ruby_dir, ".rb")
@@ -63,11 +64,7 @@ module TRuby
       if @config.compiler["generate_rbs"]
         rbs_path = compute_output_path(input_path, @config.rbs_dir, ".rbs")
         FileUtils.mkdir_p(File.dirname(rbs_path))
-        if @use_ir && parser.ir_program
-          generate_rbs_from_ir_to_path(rbs_path, parser.ir_program)
-        else
-          generate_rbs_file_to_path(rbs_path, parse_result)
-        end
+        generate_rbs_from_ir_to_path(rbs_path, parser.ir_program)
       end
 
       # Generate .d.trb file if enabled in config (legacy support)
@@ -87,25 +84,17 @@ module TRuby
     def compile_string(source, options = {})
       generate_rbs = options.fetch(:rbs, true)
 
-      parser = Parser.new(source, use_combinator: @use_ir)
-      parse_result = parser.parse
+      parser = Parser.new(source)
+      parser.parse
 
       # Transform source to Ruby code
-      ruby_output = @use_ir ? transform_with_ir(source, parser) : transform_legacy(source, parse_result)
+      ruby_output = transform_with_ir(source, parser)
 
       # Generate RBS if requested
       rbs_output = ""
-      if generate_rbs
-        if @use_ir && parser.ir_program
-          generator = IR::RBSGenerator.new
-          rbs_output = generator.generate(parser.ir_program)
-        else
-          generator = RBSGenerator.new
-          rbs_output = generator.generate(
-            parse_result[:functions] || [],
-            parse_result[:type_aliases] || []
-          )
-        end
+      if generate_rbs && parser.ir_program
+        generator = IR::RBSGenerator.new
+        rbs_output = generator.generate(parser.ir_program)
       end
 
       {
@@ -134,7 +123,7 @@ module TRuby
       end
 
       source = File.read(input_path)
-      parser = Parser.new(source, use_combinator: true)
+      parser = Parser.new(source)
       parser.parse
       parser.ir_program
     end
@@ -380,10 +369,10 @@ module TRuby
       @declaration_loader.add_search_path("./lib/types")
     end
 
-    # Transform using IR system (new approach)
+    # Transform using IR system
     def transform_with_ir(source, parser)
       ir_program = parser.ir_program
-      return transform_legacy(source, parser.parse) unless ir_program
+      return source unless ir_program
 
       # Run optimization passes if enabled
       if @optimize && @optimizer
@@ -396,33 +385,15 @@ module TRuby
       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 to a specific path
     def generate_rbs_from_ir_to_path(rbs_path, ir_program)
+      return unless ir_program
+
       generator = IR::RBSGenerator.new
       rbs_content = generator.generate(ir_program)
       File.write(rbs_path, rbs_content) unless rbs_content.strip.empty?
     end
 
-    # Legacy RBS generation to a specific path
-    def generate_rbs_file_to_path(rbs_path, parse_result)
-      generator = RBSGenerator.new
-      rbs_content = generator.generate(
-        parse_result[:functions] || [],
-        parse_result[:type_aliases] || []
-      )
-      File.write(rbs_path, rbs_content) unless rbs_content.empty?
-    end
-
     def generate_dtrb_file(input_path, out_dir)
       dtrb_path = compute_output_path(input_path, out_dir, DeclarationGenerator::DECLARATION_EXTENSION)
       FileUtils.mkdir_p(File.dirname(dtrb_path))
@@ -511,7 +482,8 @@ module TRuby
       result = source.dup
 
       # Match function definitions and remove type annotations from parameters
-      result.gsub!(/^(\s*def\s+#{TRuby::METHOD_NAME_PATTERN}\s*\()([^)]+)(\)\s*)(?::\s*[^\n]+)?(\s*$)/) do |_match|
+      # Also supports visibility modifiers: private def, protected def, public def
+      result.gsub!(/^(\s*#{TRuby::VISIBILITY_PATTERN}def\s+#{TRuby::METHOD_NAME_PATTERN}\s*\()([^)]+)(\)\s*)(?::\s*[^\n]+)?(\s*$)/) do |_match|
         indent = ::Regexp.last_match(1)
         params = ::Regexp.last_match(2)
         close_paren = ::Regexp.last_match(3)
@@ -533,6 +505,7 @@ module TRuby
       params = []
       current = ""
       depth = 0
+      brace_depth = 0
 
       params_str.each_char do |char|
         case char
@@ -542,9 +515,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
@@ -554,37 +534,128 @@ 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)
+    # Clean a single parameter (remove type annotation, preserve default value)
+    # Returns String or Array of Strings (for keyword args group)
     def clean_param(param)
-      # Match: name: Type or name (supports Unicode identifiers)
-      if (match = param.match(/^(#{TRuby::IDENTIFIER_CHAR}+)\s*:/))
+      param = param.strip
+      return nil if param.empty?
+
+      # 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]}"
+      # Match: name: Type (without default value)
+      elsif (match = param.match(/^(#{TRuby::IDENTIFIER_CHAR}+)\s*:/))
         match[1]
       else
         param
       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
 
-      result
-    end
-  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
 
-  # Legacy Compiler for backward compatibility (no IR)
-  class LegacyCompiler < Compiler
-    def initialize(config)
-      super(config, use_ir: false, optimize: false)
+      result
     end
   end
 end

data/lib/t_ruby/heredoc_detector.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module TRuby
+  # Detects regions that should be skipped during parsing:
+  # - Heredoc content
+  # - Block comments (=begin/=end)
+  class HeredocDetector
+    # Heredoc start patterns:
+    # <<IDENTIFIER, <<-IDENTIFIER, <<~IDENTIFIER
+    # <<'IDENTIFIER', <<"IDENTIFIER"
+    HEREDOC_START_PATTERN = /<<([~-])?(['"]?)(\w+)\2/
+
+    # Detect all skippable ranges in lines (heredocs and block comments)
+    # @param lines [Array<String>] source lines
+    # @return [Array<Range>] content ranges to skip (0-indexed)
+    def self.detect(lines)
+      ranges = []
+      i = 0
+
+      while i < lines.length
+        line = lines[i]
+
+        # Check for =begin block comment
+        if line.strip == "=begin"
+          start_line = i
+          i += 1
+
+          # Find =end
+          while i < lines.length
+            break if lines[i].strip == "=end"
+
+            i += 1
+          end
+
+          # Range covers from =begin to =end (inclusive)
+          ranges << (start_line..i) if i < lines.length
+        # Check for heredoc
+        elsif (match = line.match(HEREDOC_START_PATTERN))
+          delimiter = match[3]
+          squiggly = match[1] == "~"
+          start_line = i
+          i += 1
+
+          # Find closing delimiter
+          while i < lines.length
+            # For squiggly heredoc or dash heredoc, delimiter can be indented
+            # For regular heredoc, delimiter must be at line start
+            if squiggly || match[1] == "-"
+              break if lines[i].strip == delimiter
+            elsif lines[i].chomp == delimiter
+              break
+            end
+            i += 1
+          end
+
+          # Range covers content lines (after start, up to and including end delimiter)
+          ranges << ((start_line + 1)..i) if i < lines.length
+        end
+
+        i += 1
+      end
+
+      ranges
+    end
+
+    # Check if a line index is inside any skippable region
+    # @param line_index [Integer] line index to check
+    # @param heredoc_ranges [Array<Range>] ranges from detect()
+    # @return [Boolean]
+    def self.inside_heredoc?(line_index, heredoc_ranges)
+      heredoc_ranges.any? { |range| range.include?(line_index) }
+    end
+  end
+end

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
 
@@ -778,7 +782,8 @@ module TRuby
           name: info[:name],
           params: params,
           return_type: info[:return_type] ? parse_type(info[:return_type]) : nil,
-          body: body
+          body: body,
+          visibility: info[:visibility] || :public
         )
       end
 
@@ -1051,7 +1056,8 @@ module TRuby
         end
 
         return_type ||= "untyped"
-        emit("def #{node.name}: (#{params}) -> #{return_type}")
+        visibility_prefix = format_visibility(node.visibility)
+        emit("#{visibility_prefix}def #{node.name}: (#{params}) -> #{return_type}")
       end
 
       def visit_class_decl(node)
@@ -1092,6 +1098,17 @@ module TRuby
       def emit(text)
         @output << (("  " * @indent) + text)
       end
+
+      def format_visibility(visibility)
+        # RBS only supports private visibility, not protected
+        # See: https://github.com/ruby/rbs/issues/579
+        case visibility
+        when :private
+          "private "
+        else
+          ""
+        end
+      end
     end
 
     #==========================================================================

data/lib/t_ruby/lsp_server.rb

@@ -787,7 +787,7 @@ module TRuby
       lines = text.split("\n")
 
       # Parse the document to get IR
-      parser = Parser.new(text, use_combinator: true)
+      parser = Parser.new(text)
       parse_result = parser.parse
       parser.ir_program
 

data/lib/t_ruby/parser.rb

@@ -12,15 +12,16 @@ module TRuby
     IDENTIFIER_CHAR = '[\p{L}\p{N}_]'
     # Method names can end with ? or !
     METHOD_NAME_PATTERN = "#{IDENTIFIER_CHAR}+[?!]?".freeze
+    # Visibility modifiers for method definitions
+    VISIBILITY_PATTERN = '(?:(?:private|protected|public)\s+)?'
 
-    attr_reader :source, :ir_program, :use_combinator
+    attr_reader :source, :ir_program
 
-    def initialize(source, use_combinator: true, parse_body: true)
+    def initialize(source, parse_body: true)
       @source = source
       @lines = source.split("\n")
-      @use_combinator = use_combinator
       @parse_body = parse_body
-      @type_parser = ParserCombinator::TypeParser.new if use_combinator
+      @type_parser = ParserCombinator::TypeParser.new
       @body_parser = BodyParser.new if parse_body
       @ir_program = nil
     end
@@ -32,7 +33,16 @@ module TRuby
       classes = []
       i = 0
 
+      # Pre-detect heredoc regions to skip
+      heredoc_ranges = HeredocDetector.detect(@lines)
+
       while i < @lines.length
+        # Skip lines inside heredoc content
+        if HeredocDetector.inside_heredoc?(i, heredoc_ranges)
+          i += 1
+          next
+        end
+
         line = @lines[i]
 
         # Match type alias definitions
@@ -62,7 +72,7 @@ module TRuby
         end
 
         # Match function definitions (top-level only, not inside class)
-        if line.match?(/^\s*def\s+#{IDENTIFIER_CHAR}+/)
+        if line.match?(/^\s*#{VISIBILITY_PATTERN}def\s+#{IDENTIFIER_CHAR}+/)
           func_info, next_i = parse_function_with_body(i)
           if func_info
             functions << func_info
@@ -82,11 +92,9 @@ module TRuby
         classes: classes,
       }
 
-      # Build IR if combinator is enabled
-      if @use_combinator
-        builder = IR::Builder.new
-        @ir_program = builder.build(result, source: @source)
-      end
+      # Build IR
+      builder = IR::Builder.new
+      @ir_program = builder.build(result, source: @source)
 
       result
     end
@@ -97,10 +105,8 @@ module TRuby
       @ir_program
     end
 
-    # Parse a type expression using combinator (new API)
+    # Parse a type expression using combinator
     def parse_type(type_string)
-      return nil unless @use_combinator
-
       result = @type_parser.parse(type_string)
       result[:success] ? result[:type] : nil
     end
@@ -149,16 +155,14 @@ module TRuby
       alias_name = match[1]
       definition = match[2].strip
 
-      # Use combinator for complex type parsing if available
-      if @use_combinator
-        type_result = @type_parser.parse(definition)
-        if type_result[:success]
-          return {
-            name: alias_name,
-            definition: definition,
-            ir_type: type_result[:type],
-          }
-        end
+      # Use combinator for complex type parsing
+      type_result = @type_parser.parse(definition)
+      if type_result[:success]
+        return {
+          name: alias_name,
+          definition: definition,
+          ir_type: type_result[:type],
+        }
       end
 
       {
@@ -173,12 +177,14 @@ module TRuby
       # def foo(): Type         - no params but with return type
       # def foo(params)         - with params, no return type
       # def foo                  - no params, no return type
-      match = line.match(/^\s*def\s+(#{METHOD_NAME_PATTERN})\s*(?:\((.*?)\))?\s*(?::\s*(.+?))?\s*$/)
+      # Also supports visibility modifiers: private def, protected def, public def
+      match = line.match(/^\s*(?:(private|protected|public)\s+)?def\s+(#{METHOD_NAME_PATTERN})\s*(?:\((.*?)\))?\s*(?::\s*(.+?))?\s*$/)
       return nil unless match
 
-      function_name = match[1]
-      params_str = match[2] || ""
-      return_type_str = match[3]&.strip
+      visibility = match[1] ? match[1].to_sym : :public
+      function_name = match[2]
+      params_str = match[3] || ""
+      return_type_str = match[4]&.strip
 
       # Validate return type if present
       if return_type_str
@@ -191,10 +197,11 @@ module TRuby
         name: function_name,
         params: params,
         return_type: return_type_str,
+        visibility: visibility,
       }
 
-      # Parse return type with combinator if available
-      if @use_combinator && return_type_str
+      # Parse return type with combinator
+      if return_type_str
         type_result = @type_parser.parse(return_type_str)
         result[:ir_return_type] = type_result[:type] if type_result[:success]
       end
@@ -237,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
@@ -258,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
@@ -274,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]
@@ -284,10 +317,159 @@ 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 if available
-      if @use_combinator && type_str
+      # Parse type with combinator
+      if type_str
         type_result = @type_parser.parse(type_str)
         result[:ir_type] = type_result[:type] if type_result[:success]
       end
@@ -326,7 +508,7 @@ module TRuby
         current_line = @lines[i]
 
         # Match method definitions inside class
-        if current_line.match?(/^\s*def\s+#{IDENTIFIER_CHAR}+/)
+        if current_line.match?(/^\s*#{VISIBILITY_PATTERN}def\s+#{IDENTIFIER_CHAR}+/)
           method_info, next_i = parse_method_in_class(i, class_end)
           if method_info
             methods << method_info
@@ -438,10 +620,8 @@ module TRuby
             }
 
             # Parse member type with combinator
-            if @use_combinator
-              type_result = @type_parser.parse(member[:type])
-              member[:ir_type] = type_result[:type] if type_result[:success]
-            end
+            type_result = @type_parser.parse(member[:type])
+            member[:ir_type] = type_result[:type] if type_result[:success]
 
             members << member
           end
@@ -453,11 +633,4 @@ module TRuby
       [{ name: interface_name, members: members }, i]
     end
   end
-
-  # Legacy Parser for backward compatibility (regex-only)
-  class LegacyParser < Parser
-    def initialize(source)
-      super(source, use_combinator: false)
-    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.39"
+  VERSION = "0.0.41"
 end

data/lib/t_ruby.rb

@@ -5,12 +5,14 @@ require_relative "t_ruby/version_checker"
 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"
 
 # Basic components
 require_relative "t_ruby/type_alias_registry"
+require_relative "t_ruby/heredoc_detector"
 require_relative "t_ruby/body_parser"
 require_relative "t_ruby/parser"
 require_relative "t_ruby/union_type_parser"
@@ -18,7 +20,6 @@ require_relative "t_ruby/generic_type_parser"
 require_relative "t_ruby/intersection_type_parser"
 require_relative "t_ruby/type_erasure"
 require_relative "t_ruby/error_handler"
-require_relative "t_ruby/rbs_generator"
 require_relative "t_ruby/declaration_generator"
 require_relative "t_ruby/compiler"
 require_relative "t_ruby/lsp_server"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: t-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.39
+  version: 0.0.41
 platform: ruby
 authors:
 - Y. Fred Kim
@@ -52,15 +52,16 @@ files:
 - lib/t_ruby/docs_example_verifier.rb
 - lib/t_ruby/error_handler.rb
 - lib/t_ruby/generic_type_parser.rb
+- lib/t_ruby/heredoc_detector.rb
 - lib/t_ruby/intersection_type_parser.rb
 - lib/t_ruby/ir.rb
 - lib/t_ruby/lsp_server.rb
 - lib/t_ruby/package_manager.rb
 - lib/t_ruby/parser.rb
 - lib/t_ruby/parser_combinator.rb
-- lib/t_ruby/rbs_generator.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

data/lib/t_ruby/rbs_generator.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module TRuby
-  class RBSGenerator
-    def initialize
-      # RBS generation configuration
-    end
-
-    def generate(functions, type_aliases)
-      # Add type aliases
-      lines = type_aliases.map do |type_alias|
-        generate_type_alias(type_alias)
-      end
-
-      lines << "" if type_aliases.any? && functions.any?
-
-      # Add function signatures
-      functions.each do |func|
-        lines << generate_function_signature(func)
-      end
-
-      lines.compact.join("\n")
-    end
-
-    def generate_type_aliases(aliases)
-      aliases.map { |alias_def| generate_type_alias(alias_def) }.join("\n")
-    end
-
-    def generate_type_alias(type_alias)
-      name = type_alias[:name]
-      definition = type_alias[:definition]
-
-      "type #{name} = #{definition}"
-    end
-
-    def generate_function_signature(func)
-      name = func[:name]
-      params = func[:params] || []
-      return_type = func[:return_type]
-
-      param_str = format_parameters(params)
-      return_str = format_return_type(return_type)
-
-      "def #{name}: (#{param_str}) -> #{return_str}"
-    end
-
-    private
-
-    def format_parameters(params)
-      return if params.empty?
-
-      param_strs = params.map do |param|
-        param_name = param[:name]
-        param_type = param[:type] || "Object"
-
-        "#{param_name}: #{param_type}"
-      end
-
-      param_strs.join(", ")
-    end
-
-    def format_return_type(return_type)
-      return "void" if return_type == "void"
-      return "nil" if return_type.nil?
-
-      return_type
-    end
-  end
-end