t-ruby 0.0.39 → 0.0.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64bc7ea0ab44e83d6580d07227fee508ae3b5e53bc0e6b19b8164857eaf31376
-  data.tar.gz: 01da8585df97030974563634d8212058a3d3325ca9bc05188ae12ccf1cdc6770
+  metadata.gz: 54f0b9008d5a42a8cbf851eac8a0eb540670c3c87018dd87182baf6ab30c7d55
+  data.tar.gz: 42929dd91ae55ea84e75fd6978298deea2fec1d3517a801bde06af6f70865557
 SHA512:
-  metadata.gz: b0bf9cd9518368e5ef256dd1851285fbbb78404b16c837346ecb286bfde37d2b8f8f5738782629efb5507fb7419eaea197726ae85f1ccb9481c09abc26d80a7f
-  data.tar.gz: 67de07897cec9ef86c5df0798c4f2d44e1d54da0d8bfe799386eb544c28a4c0d5595f17dcc0c0bbc4236a44c17e76f1283fc75a9cd4452cee40f34daa86ef609
+  metadata.gz: 20916cbdb9a4d62bd9208c8496df8e8f425885c600d5caa9ef0d5a545c4d52a62fa66d05157bfc89a0c57328658f6ecb08889336352e76b4cfb757518365f50b
+  data.tar.gz: b6125521d066808e825747418d794ca6adb94503e7d89b61fe5a9bb009e2c2fcc49952b0ea3fd12f5c0bb51de9d20de0ff3a7b4f0ab37358d0616010e1f9ca55

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)
@@ -558,10 +530,13 @@ module TRuby
       params.join(", ")
     end
 
-    # Clean a single parameter (remove type annotation)
+    # Clean a single parameter (remove type annotation, preserve default value)
     def clean_param(param)
-      # Match: name: Type or name (supports Unicode identifiers)
-      if (match = param.match(/^(#{TRuby::IDENTIFIER_CHAR}+)\s*:/))
+      # 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
@@ -580,11 +555,4 @@ module TRuby
       result
     end
   end
-
-  # Legacy Compiler for backward compatibility (no IR)
-  class LegacyCompiler < Compiler
-    def initialize(config)
-      super(config, use_ir: false, optimize: false)
-    end
-  end
 end

data/lib/t_ruby/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

@@ -778,7 +778,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 +1052,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 +1094,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
@@ -286,8 +293,8 @@ module TRuby
         type: type_str,
       }
 
-      # 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 +333,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 +445,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 +458,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/version.rb

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

data/lib/t_ruby.rb

@@ -11,6 +11,7 @@ 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 +19,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.40
 platform: ruby
 authors:
 - Y. Fred Kim
@@ -52,13 +52,13 @@ 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/type_alias_registry.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