t-ruby 0.0.38 → 0.0.40

data/lib/t_ruby/parser.rb

@@ -7,13 +7,22 @@ module TRuby
     # Type names that are recognized as valid
     VALID_TYPES = %w[String Integer Boolean Array Hash Symbol void nil].freeze
 
-    attr_reader :source, :ir_program, :use_combinator
+    # Pattern for method/variable names that supports Unicode characters
+    # \p{L} matches any Unicode letter, \p{N} matches any Unicode number
+    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+)?'
 
-    def initialize(source, use_combinator: true)
+    attr_reader :source, :ir_program
+
+    def initialize(source, parse_body: true)
       @source = source
       @lines = source.split("\n")
-      @use_combinator = use_combinator
-      @type_parser = ParserCombinator::TypeParser.new if use_combinator
+      @parse_body = parse_body
+      @type_parser = ParserCombinator::TypeParser.new
+      @body_parser = BodyParser.new if parse_body
       @ir_program = nil
     end
 
@@ -21,9 +30,19 @@ module TRuby
       functions = []
       type_aliases = []
       interfaces = []
+      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
@@ -42,10 +61,24 @@ module TRuby
           end
         end
 
-        # Match function definitions
-        if line.match?(/^\s*def\s+\w+/)
-          func_info = parse_function_definition(line)
-          functions << func_info if func_info
+        # Match class definitions
+        if line.match?(/^\s*class\s+\w+/)
+          class_info, next_i = parse_class(i)
+          if class_info
+            classes << class_info
+            i = next_i
+            next
+          end
+        end
+
+        # Match function definitions (top-level only, not inside class)
+        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
+            i = next_i
+            next
+          end
         end
 
         i += 1
@@ -56,13 +89,12 @@ module TRuby
         functions: functions,
         type_aliases: type_aliases,
         interfaces: interfaces,
+        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
@@ -73,16 +105,49 @@ 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
 
     private
 
+    # 최상위 함수를 본문까지 포함하여 파싱
+    def parse_function_with_body(start_index)
+      line = @lines[start_index]
+      func_info = parse_function_definition(line)
+      return [nil, start_index] unless func_info
+
+      def_indent = line.match(/^(\s*)/)[1].length
+      i = start_index + 1
+      body_start = i
+      body_end = i
+
+      # end 키워드 찾기
+      while i < @lines.length
+        current_line = @lines[i]
+
+        if current_line.match?(/^\s*end\s*$/)
+          end_indent = current_line.match(/^(\s*)/)[1].length
+          if end_indent <= def_indent
+            body_end = i
+            break
+          end
+        end
+
+        i += 1
+      end
+
+      # 본문 파싱 (parse_body 옵션이 활성화된 경우)
+      if @parse_body && @body_parser && body_start < body_end
+        func_info[:body_ir] = @body_parser.parse(@lines, body_start, body_end)
+        func_info[:body_range] = { start: body_start, end: body_end }
+      end
+
+      [func_info, i]
+    end
+
     def parse_type_alias(line)
       match = line.match(/^\s*type\s+(\w+)\s*=\s*(.+?)\s*$/)
       return nil unless match
@@ -90,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
 
       {
@@ -109,12 +172,19 @@ module TRuby
     end
 
     def parse_function_definition(line)
-      match = line.match(/^\s*def\s+(\w+)\s*\((.*?)\)\s*(?::\s*(.+?))?\s*$/)
+      # Match methods with or without parentheses
+      # def foo(params): Type   - with params and return type
+      # def foo(): Type         - no params but with return type
+      # def foo(params)         - with params, no return type
+      # def foo                  - no params, no return type
+      # 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
@@ -127,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
@@ -222,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
@@ -231,6 +302,127 @@ module TRuby
       result
     end
 
+    def parse_class(start_index)
+      line = @lines[start_index]
+      match = line.match(/^\s*class\s+(\w+)(?:\s*<\s*(\w+))?/)
+      return [nil, start_index] unless match
+
+      class_name = match[1]
+      superclass = match[2]
+      methods = []
+      instance_vars = []
+      i = start_index + 1
+      class_indent = line.match(/^(\s*)/)[1].length
+      class_end = i
+
+      # 먼저 클래스의 끝을 찾음
+      temp_i = i
+      while temp_i < @lines.length
+        current_line = @lines[temp_i]
+        if current_line.match?(/^\s*end\s*$/)
+          end_indent = current_line.match(/^(\s*)/)[1].length
+          if end_indent <= class_indent
+            class_end = temp_i
+            break
+          end
+        end
+        temp_i += 1
+      end
+
+      while i < class_end
+        current_line = @lines[i]
+
+        # Match method definitions inside class
+        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
+            i = next_i
+            next
+          end
+        end
+
+        i += 1
+      end
+
+      # 메서드 본문에서 인스턴스 변수 추출
+      methods.each do |method_info|
+        extract_instance_vars_from_body(method_info[:body_ir], instance_vars)
+      end
+
+      # Try to infer instance variable types from initialize parameters
+      init_method = methods.find { |m| m[:name] == "initialize" }
+      if init_method
+        instance_vars.each do |ivar|
+          # Find matching parameter (e.g., @name = name)
+          matching_param = init_method[:params]&.find { |p| p[:name] == ivar[:name] }
+          ivar[:type] = matching_param[:type] if matching_param && matching_param[:type]
+          ivar[:ir_type] = matching_param[:ir_type] if matching_param && matching_param[:ir_type]
+        end
+      end
+
+      [{
+        name: class_name,
+        superclass: superclass,
+        methods: methods,
+        instance_vars: instance_vars,
+      }, class_end,]
+    end
+
+    # 클래스 내부의 메서드를 본문까지 포함하여 파싱
+    def parse_method_in_class(start_index, class_end)
+      line = @lines[start_index]
+      method_info = parse_function_definition(line)
+      return [nil, start_index] unless method_info
+
+      def_indent = line.match(/^(\s*)/)[1].length
+      i = start_index + 1
+      body_start = i
+      body_end = i
+
+      # 메서드의 end 키워드 찾기
+      while i < class_end
+        current_line = @lines[i]
+
+        if current_line.match?(/^\s*end\s*$/)
+          end_indent = current_line.match(/^(\s*)/)[1].length
+          if end_indent <= def_indent
+            body_end = i
+            break
+          end
+        end
+
+        i += 1
+      end
+
+      # 본문 파싱 (parse_body 옵션이 활성화된 경우)
+      if @parse_body && @body_parser && body_start < body_end
+        method_info[:body_ir] = @body_parser.parse(@lines, body_start, body_end)
+        method_info[:body_range] = { start: body_start, end: body_end }
+      end
+
+      [method_info, i]
+    end
+
+    # 본문 IR에서 인스턴스 변수 추출
+    def extract_instance_vars_from_body(body_ir, instance_vars)
+      return unless body_ir.is_a?(IR::Block)
+
+      body_ir.statements.each do |stmt|
+        case stmt
+        when IR::Assignment
+          if stmt.target.start_with?("@") && !stmt.target.start_with?("@@")
+            ivar_name = stmt.target[1..] # @ 제거
+            unless instance_vars.any? { |iv| iv[:name] == ivar_name }
+              instance_vars << { name: ivar_name }
+            end
+          end
+        when IR::Block
+          extract_instance_vars_from_body(stmt, instance_vars)
+        end
+      end
+    end
+
     def parse_interface(start_index)
       line = @lines[start_index]
       match = line.match(/^\s*interface\s+([\w:]+)/)
@@ -253,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
@@ -268,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/type_checker.rb

@@ -1,38 +1,41 @@
 # frozen_string_literal: true
 
 module TRuby
-  # Represents a type checking error
-  class TypeCheckError
-    attr_reader :message, :location, :expected, :actual, :suggestion, :severity
+  # Represents a type checking error (can be raised as an exception)
+  class TypeCheckError < StandardError
+    attr_reader :error_message, :location, :expected, :actual, :suggestion, :severity
 
     def initialize(message:, location: nil, expected: nil, actual: nil, suggestion: nil, severity: :error)
-      @message = message
+      @error_message = message
       @location = location
       @expected = expected
       @actual = actual
       @suggestion = suggestion
       @severity = severity
-    end
-
-    def to_s
-      parts = [@message]
-      parts << "  Expected: #{@expected}" if @expected
-      parts << "  Actual: #{@actual}" if @actual
-      parts << "  Suggestion: #{@suggestion}" if @suggestion
-      parts << "  at #{@location}" if @location
-      parts.join("\n")
+      super(build_full_message)
     end
 
     def to_diagnostic
       {
         severity: @severity,
-        message: @message,
+        message: @error_message,
         location: @location,
         expected: @expected,
         actual: @actual,
         suggestion: @suggestion,
       }
     end
+
+    private
+
+    def build_full_message
+      parts = [@error_message]
+      parts << "  Expected: #{@expected}" if @expected
+      parts << "  Actual: #{@actual}" if @actual
+      parts << "  Suggestion: #{@suggestion}" if @suggestion
+      parts << "  at #{@location}" if @location
+      parts.join("\n")
+    end
   end
 
   # Type hierarchy for subtype checking

data/lib/t_ruby/type_env.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module TRuby
+  # TypeEnv - 타입 환경 (스코프 체인)
+  # TypeScript의 Checker에서 심볼 타입을 추적하는 방식을 참고
+  class TypeEnv
+    attr_reader :parent, :bindings, :instance_vars
+
+    def initialize(parent = nil)
+      @parent = parent
+      @bindings = {}      # 지역 변수 { name => type }
+      @instance_vars = {} # 인스턴스 변수 { name => type }
+      @class_vars = {}    # 클래스 변수 { name => type }
+    end
+
+    # 지역 변수 타입 정의
+    # @param name [String] 변수 이름
+    # @param type [IR::TypeNode, String] 타입
+    def define(name, type)
+      @bindings[name] = type
+    end
+
+    # 변수 타입 조회 (스코프 체인 탐색)
+    # @param name [String] 변수 이름
+    # @return [IR::TypeNode, String, nil] 타입 또는 nil
+    def lookup(name)
+      # 인스턴스 변수
+      if name.start_with?("@") && !name.start_with?("@@")
+        return lookup_instance_var(name)
+      end
+
+      # 클래스 변수
+      if name.start_with?("@@")
+        return lookup_class_var(name)
+      end
+
+      # 지역 변수 또는 메서드 파라미터
+      return @bindings[name] if @bindings.key?(name)
+
+      # 부모 스코프에서 검색
+      @parent&.lookup(name)
+    end
+
+    # 인스턴스 변수 타입 정의
+    # @param name [String] 변수 이름 (@포함)
+    # @param type [IR::TypeNode, String] 타입
+    def define_instance_var(name, type)
+      # @ 접두사 정규화
+      normalized = name.start_with?("@") ? name : "@#{name}"
+      @instance_vars[normalized] = type
+    end
+
+    # 인스턴스 변수 타입 조회
+    # @param name [String] 변수 이름 (@포함)
+    # @return [IR::TypeNode, String, nil] 타입 또는 nil
+    def lookup_instance_var(name)
+      normalized = name.start_with?("@") ? name : "@#{name}"
+      return @instance_vars[normalized] if @instance_vars.key?(normalized)
+
+      @parent&.lookup_instance_var(normalized)
+    end
+
+    # 클래스 변수 타입 정의
+    # @param name [String] 변수 이름 (@@포함)
+    # @param type [IR::TypeNode, String] 타입
+    def define_class_var(name, type)
+      normalized = name.start_with?("@@") ? name : "@@#{name}"
+      @class_vars[normalized] = type
+    end
+
+    # 클래스 변수 타입 조회
+    # @param name [String] 변수 이름 (@@포함)
+    # @return [IR::TypeNode, String, nil] 타입 또는 nil
+    def lookup_class_var(name)
+      normalized = name.start_with?("@@") ? name : "@@#{name}"
+      return @class_vars[normalized] if @class_vars.key?(normalized)
+
+      @parent&.lookup_class_var(normalized)
+    end
+
+    # 자식 스코프 생성 (블록, 람다 등)
+    # @return [TypeEnv] 새 자식 스코프
+    def child_scope
+      TypeEnv.new(self)
+    end
+
+    # 현재 스코프에서 정의된 모든 변수 이름
+    # @return [Array<String>] 변수 이름 배열
+    def local_names
+      @bindings.keys
+    end
+
+    # 현재 스코프에서 정의된 모든 인스턴스 변수 이름
+    # @return [Array<String>] 인스턴스 변수 이름 배열
+    def instance_var_names
+      @instance_vars.keys
+    end
+
+    # 변수가 현재 스코프에 정의되어 있는지 확인
+    # @param name [String] 변수 이름
+    # @return [Boolean]
+    def defined_locally?(name)
+      @bindings.key?(name)
+    end
+
+    # 스코프 깊이 (디버깅용)
+    # @return [Integer] 스코프 깊이
+    def depth
+      @parent ? @parent.depth + 1 : 0
+    end
+
+    # 스코프 체인에서 모든 변수 수집
+    # @return [Hash] 모든 변수의 { name => type }
+    def all_bindings
+      parent_bindings = @parent ? @parent.all_bindings : {}
+      parent_bindings.merge(@bindings)
+    end
+
+    # 디버그 출력
+    def to_s
+      parts = ["TypeEnv(depth=#{depth})"]
+      parts << "  locals: #{@bindings.keys.join(", ")}" if @bindings.any?
+      parts << "  ivars: #{@instance_vars.keys.join(", ")}" if @instance_vars.any?
+      parts.join("\n")
+    end
+  end
+end

data/lib/t_ruby/version.rb

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

data/lib/t_ruby/watcher.rb

@@ -80,14 +80,18 @@ module TRuby
 
     private
 
+    def watch_directory(path)
+      File.directory?(path) ? path : File.dirname(path)
+    end
+
     def watch_directories
-      @paths.map do |path|
-        if File.directory?(path)
-          path
-        else
-          File.dirname(path)
-        end
-      end.uniq
+      if @paths == [File.expand_path(".")]
+        # Default case: only watch source_include directories from config
+        @config.source_include.map { |dir| File.expand_path(dir) }.select { |dir| Dir.exist?(dir) }
+      else
+        # Specific paths provided: watch those paths
+        @paths.map { |path| watch_directory(path) }.uniq
+      end
     end
 
     def handle_changes(modified, added, removed)
@@ -243,20 +247,21 @@ module TRuby
     def find_source_files_by_extension(ext)
       files = []
 
-      # If watching specific paths, use those paths
-      # Otherwise, use Config's find_source_files which respects include/exclude patterns
-      if @paths == [File.expand_path(".")]
-        # Default case: use config's src_dir with include/exclude patterns
-        files = @config.find_source_files.select { |f| f.end_with?(ext) }
-      else
-        # Specific paths provided: search in those paths but still apply exclude patterns
-        @paths.each do |path|
-          if File.directory?(path)
-            Dir.glob(File.join(path, "**", "*#{ext}")).each do |file|
-              files << file unless @config.excluded?(file)
-            end
-          elsif File.file?(path) && path.end_with?(ext) && !@config.excluded?(path)
-            files << path
+      # Always search in source_include directories only
+      source_paths = if @paths == [File.expand_path(".")]
+                       @config.source_include.map { |dir| File.expand_path(dir) }
+                     else
+                       @paths.map { |path| File.expand_path(path) }
+                     end
+
+      source_paths.each do |path|
+        if File.file?(path)
+          # Handle single file path
+          files << path if path.end_with?(ext) && !@config.excluded?(path)
+        elsif Dir.exist?(path)
+          # Handle directory path
+          Dir.glob(File.join(path, "**", "*#{ext}")).each do |file|
+            files << file unless @config.excluded?(file)
           end
         end
       end

data/lib/t_ruby.rb

@@ -11,13 +11,14 @@ 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"
 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"
@@ -29,6 +30,8 @@ require_relative "t_ruby/constraint_checker"
 require_relative "t_ruby/type_inferencer"
 require_relative "t_ruby/runtime_validator"
 require_relative "t_ruby/type_checker"
+require_relative "t_ruby/type_env"
+require_relative "t_ruby/ast_type_inferrer"
 require_relative "t_ruby/cache"
 require_relative "t_ruby/package_manager"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: t-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.38
+  version: 0.0.40
 platform: ruby
 authors:
 - Y. Fred Kim
@@ -36,7 +36,9 @@ files:
 - README.md
 - bin/trc
 - lib/t_ruby.rb
+- lib/t_ruby/ast_type_inferrer.rb
 - lib/t_ruby/benchmark.rb
+- lib/t_ruby/body_parser.rb
 - lib/t_ruby/bundler_integration.rb
 - lib/t_ruby/cache.rb
 - lib/t_ruby/cli.rb
@@ -50,17 +52,18 @@ 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
 - lib/t_ruby/type_checker.rb
+- lib/t_ruby/type_env.rb
 - lib/t_ruby/type_erasure.rb
 - lib/t_ruby/type_inferencer.rb
 - lib/t_ruby/union_type_parser.rb
@@ -69,7 +72,7 @@ files:
 - lib/t_ruby/watcher.rb
 homepage: https://type-ruby.github.io
 licenses:
-- MIT
+- BSD-2-Clause
 metadata:
   rubygems_mfa_required: 'true'
 rdoc_options: []