t-ruby 0.0.38 → 0.0.40

data/lib/t_ruby/compiler.rb

@@ -3,18 +3,29 @@
 require "fileutils"
 
 module TRuby
+  # Pattern for method names that supports Unicode characters
+  # \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
 
+    def type_check?
+      @config.type_check?
+    end
+
     def compile(input_path)
       unless File.exist?(input_path)
         raise ArgumentError, "File not found: #{input_path}"
@@ -32,11 +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? && 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")
@@ -48,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)
@@ -72,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
 
       {
@@ -119,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
@@ -215,6 +219,140 @@ module TRuby
 
     private
 
+    # Check types in IR program and raise TypeCheckError if mismatches found
+    # @param ir_program [IR::Program] IR program to check
+    # @param file_path [String] source file path for error messages
+    def check_types(ir_program, file_path)
+      ir_program.declarations.each do |decl|
+        case decl
+        when IR::MethodDef
+          check_method_return_type(decl, nil, file_path)
+        when IR::ClassDecl
+          decl.body.each do |member|
+            check_method_return_type(member, decl, file_path) if member.is_a?(IR::MethodDef)
+          end
+        end
+      end
+    end
+
+    # Check if method's inferred return type matches declared return type
+    # @param method [IR::MethodDef] method to check
+    # @param class_def [IR::ClassDef, nil] containing class if any
+    # @param file_path [String] source file path for error messages
+    def check_method_return_type(method, class_def, file_path)
+      # Skip if no explicit return type annotation
+      return unless method.return_type
+
+      declared_type = normalize_type(method.return_type.to_rbs)
+
+      # Create type environment for the class context
+      class_env = create_class_env(class_def) if class_def
+
+      # Infer actual return type
+      inferred_type = @type_inferrer.infer_method_return_type(method, class_env)
+      inferred_type = normalize_type(inferred_type || "nil")
+
+      # Check compatibility
+      return if types_compatible?(inferred_type, declared_type)
+
+      location = method.location ? "#{file_path}:#{method.location}" : file_path
+      method_name = class_def ? "#{class_def.name}##{method.name}" : method.name
+
+      raise TypeCheckError.new(
+        message: "Return type mismatch in method '#{method_name}': " \
+                 "declared '#{declared_type}' but inferred '#{inferred_type}'",
+        location: location,
+        expected: declared_type,
+        actual: inferred_type
+      )
+    end
+
+    # Create type environment for class context
+    # @param class_def [IR::ClassDecl] class declaration
+    # @return [TypeEnv] type environment with instance variables
+    def create_class_env(class_def)
+      env = TypeEnv.new
+
+      # Register instance variables from class
+      class_def.instance_vars&.each do |ivar|
+        type = ivar.type_annotation&.to_rbs || "untyped"
+        env.define_instance_var(ivar.name, type)
+      end
+
+      env
+    end
+
+    # Normalize type string for comparison
+    # @param type [String] type string
+    # @return [String] normalized type string
+    def normalize_type(type)
+      return "untyped" if type.nil?
+
+      normalized = type.to_s.strip
+
+      # Normalize boolean types (bool/Boolean/TrueClass/FalseClass -> bool)
+      case normalized
+      when "Boolean", "TrueClass", "FalseClass"
+        "bool"
+      else
+        normalized
+      end
+    end
+
+    # Check if inferred type is compatible with declared type
+    # @param inferred [String] inferred type
+    # @param declared [String] declared type
+    # @return [Boolean] true if compatible
+    def types_compatible?(inferred, declared)
+      # Exact match
+      return true if inferred == declared
+
+      # untyped is compatible with anything
+      return true if inferred == "untyped" || declared == "untyped"
+
+      # void is compatible with anything (no return value check)
+      return true if declared == "void"
+
+      # nil is compatible with nullable types
+      return true if inferred == "nil" && declared.end_with?("?")
+
+      # Subtype relationships
+      return true if subtype_of?(inferred, declared)
+
+      # Handle union types in declared
+      if declared.include?("|")
+        declared_types = declared.split("|").map(&:strip)
+        return true if declared_types.include?(inferred)
+        return true if declared_types.any? { |t| types_compatible?(inferred, t) }
+      end
+
+      # Handle union types in inferred - all must be compatible
+      if inferred.include?("|")
+        inferred_types = inferred.split("|").map(&:strip)
+        return inferred_types.all? { |t| types_compatible?(t, declared) }
+      end
+
+      false
+    end
+
+    # Check if subtype is a subtype of supertype
+    # @param subtype [String] potential subtype
+    # @param supertype [String] potential supertype
+    # @return [Boolean] true if subtype
+    def subtype_of?(subtype, supertype)
+      # Handle nullable - X is subtype of X?
+      return true if supertype.end_with?("?") && supertype[0..-2] == subtype
+
+      # Numeric hierarchy
+      return true if subtype == "Integer" && supertype == "Numeric"
+      return true if subtype == "Float" && supertype == "Numeric"
+
+      # Object is supertype of everything
+      return true if supertype == "Object"
+
+      false
+    end
+
     # Resolve path to absolute path, following symlinks
     # Falls back to expand_path if realpath fails (e.g., file doesn't exist yet)
     def resolve_path(path)
@@ -231,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
@@ -247,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))
@@ -362,7 +482,8 @@ module TRuby
       result = source.dup
 
       # Match function definitions and remove type annotations from parameters
-      result.gsub!(/^(\s*def\s+\w+\s*\()([^)]+)(\)\s*)(?::\s*[^\n]+)?(\s*$)/) do |_match|
+      # 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)
@@ -409,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
-      if (match = param.match(/^(\w+)\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
@@ -431,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/config.rb

@@ -24,6 +24,7 @@ module TRuby
       "compiler" => {
         "strictness" => "standard",
         "generate_rbs" => true,
+        "type_check" => true,
         "target_ruby" => "3.0",
         "experimental" => [],
         "checks" => {
@@ -89,6 +90,12 @@ module TRuby
       @compiler["generate_rbs"] != false
     end
 
+    # Check if type checking is enabled
+    # @return [Boolean] true if type checking is enabled (default: true)
+    def type_check?
+      @compiler["type_check"] != false
+    end
+
     # Get target Ruby version
     # @return [String] target Ruby version (e.g., "3.0", "3.2")
     def target_ruby

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

@@ -83,15 +83,16 @@ module TRuby
 
     # Class declaration
     class ClassDecl < Node
-      attr_accessor :name, :superclass, :implements, :type_params, :body
+      attr_accessor :name, :superclass, :implements, :type_params, :body, :instance_vars
 
-      def initialize(name:, superclass: nil, implements: [], type_params: [], body: [], **opts)
+      def initialize(name:, superclass: nil, implements: [], type_params: [], body: [], instance_vars: [], **opts)
         super(**opts)
         @name = name
         @superclass = superclass
         @implements = implements
         @type_params = type_params
         @body = body
+        @instance_vars = instance_vars
       end
 
       def children
@@ -99,6 +100,17 @@ module TRuby
       end
     end
 
+    # Instance variable declaration
+    class InstanceVariable < Node
+      attr_accessor :name, :type_annotation
+
+      def initialize(name:, type_annotation: nil, **opts)
+        super(**opts)
+        @name = name
+        @type_annotation = type_annotation
+      end
+    end
+
     # Module declaration
     class ModuleDecl < Node
       attr_accessor :name, :body
@@ -686,6 +698,11 @@ module TRuby
           declarations << build_interface(interface_info)
         end
 
+        # Build classes
+        (parse_result[:classes] || []).each do |class_info|
+          declarations << build_class(class_info)
+        end
+
         # Build functions/methods
         (parse_result[:functions] || []).each do |func_info|
           declarations << build_method(func_info)
@@ -724,6 +741,28 @@ module TRuby
         )
       end
 
+      def build_class(info)
+        # Build methods
+        methods = (info[:methods] || []).map do |method_info|
+          build_method(method_info)
+        end
+
+        # Build instance variables
+        instance_vars = (info[:instance_vars] || []).map do |ivar|
+          InstanceVariable.new(
+            name: ivar[:name],
+            type_annotation: ivar[:type] ? parse_type(ivar[:type]) : nil
+          )
+        end
+
+        ClassDecl.new(
+          name: info[:name],
+          superclass: info[:superclass],
+          body: methods,
+          instance_vars: instance_vars
+        )
+      end
+
       def build_method(info)
         params = (info[:params] || []).map do |param|
           Parameter.new(
@@ -732,10 +771,15 @@ module TRuby
           )
         end
 
+        # 본문 IR이 있으면 사용 (BodyParser에서 파싱됨)
+        body = info[:body_ir]
+
         MethodDef.new(
           name: info[:name],
           params: params,
-          return_type: info[:return_type] ? parse_type(info[:return_type]) : nil
+          return_type: info[:return_type] ? parse_type(info[:return_type]) : nil,
+          body: body,
+          visibility: info[:visibility] || :public
         )
       end
 
@@ -947,9 +991,12 @@ module TRuby
     class RBSGenerator < Visitor
       attr_reader :output
 
-      def initialize
+      def initialize(enable_inference: true)
         @output = []
         @indent = 0
+        @enable_inference = enable_inference
+        @inferrer = TRuby::ASTTypeInferrer.new if enable_inference
+        @class_env = nil # 현재 클래스의 타입 환경
       end
 
       def generate(program)
@@ -988,26 +1035,76 @@ module TRuby
       def visit_method_def(node)
         params = node.params.map do |param|
           type = param.type_annotation&.to_rbs || "untyped"
-          "#{type} #{param.name}"
+          "#{param.name}: #{type}"
         end.join(", ")
 
-        return_type = node.return_type&.to_rbs || "untyped"
-        emit("def #{node.name}: (#{params}) -> #{return_type}")
+        # 반환 타입: 명시적 타입 > 추론된 타입 > untyped
+        return_type = node.return_type&.to_rbs
+
+        # initialize 메서드는 특별 처리: 명시적 타입이 없으면 void
+        # Ruby에서 initialize는 생성자이며, 실제 인스턴스 생성은 Class.new가 담당
+        if node.name == "initialize" && return_type.nil?
+          return_type = "void"
+        elsif return_type.nil? && @enable_inference && @inferrer && node.body
+          # 명시적 반환 타입이 없으면 추론 시도
+          inferred = @inferrer.infer_method_return_type(node, @class_env)
+          return_type = inferred if inferred && inferred != "untyped"
+        end
+
+        return_type ||= "untyped"
+        visibility_prefix = format_visibility(node.visibility)
+        emit("#{visibility_prefix}def #{node.name}: (#{params}) -> #{return_type}")
       end
 
       def visit_class_decl(node)
         emit("class #{node.name}")
         @indent += 1
+
+        # 클래스 타입 환경 생성
+        @class_env = TRuby::TypeEnv.new if @enable_inference
+
+        # 인스턴스 변수 타입 등록
+        (node.instance_vars || []).each do |ivar|
+          if @class_env && ivar.type_annotation
+            @class_env.define_instance_var("@#{ivar.name}", ivar.type_annotation.to_rbs)
+          end
+
+          # Emit instance variables first
+          visit_instance_variable(ivar)
+        end
+
+        # Add blank line between ivars and methods if both exist
+        @output << "" if node.instance_vars&.any? && node.body&.any?
+
+        # Emit methods
         node.body.each { |member| visit(member) }
+
+        @class_env = nil
         @indent -= 1
         emit("end")
       end
 
+      def visit_instance_variable(node)
+        type = node.type_annotation&.to_rbs || "untyped"
+        emit("@#{node.name}: #{type}")
+      end
+
       private
 
       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