t-ruby 0.0.38 → 0.0.39

data/lib/t_ruby/compiler.rb

@@ -3,6 +3,11 @@
 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
+
   class Compiler
     attr_reader :declaration_loader, :use_ir, :optimizer
 
@@ -12,9 +17,14 @@ module TRuby
       @optimize = optimize
       @declaration_loader = DeclarationLoader.new
       @optimizer = IR::Optimizer.new if use_ir && 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}"
@@ -35,6 +45,11 @@ module TRuby
       parser = Parser.new(source, use_combinator: @use_ir)
       parse_result = parser.parse
 
+      # Run type checking if enabled
+      if type_check? && @use_ir && 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)
 
@@ -215,6 +230,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)
@@ -362,7 +511,7 @@ 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|
+      result.gsub!(/^(\s*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)
@@ -411,8 +560,8 @@ module TRuby
 
     # Clean a single parameter (remove type annotation)
     def clean_param(param)
-      # Match: name: Type or name
-      if (match = param.match(/^(\w+)\s*:/))
+      # Match: name: Type or name (supports Unicode identifiers)
+      if (match = param.match(/^(#{TRuby::IDENTIFIER_CHAR}+)\s*:/))
         match[1]
       else
         param

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/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,14 @@ 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
         )
       end
 
@@ -947,9 +990,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,21 +1034,59 @@ 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"
+        # 반환 타입: 명시적 타입 > 추론된 타입 > 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"
         emit("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)

data/lib/t_ruby/parser.rb

@@ -7,13 +7,21 @@ module TRuby
     # Type names that are recognized as valid
     VALID_TYPES = %w[String Integer Boolean Array Hash Symbol void nil].freeze
 
+    # 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
+
     attr_reader :source, :ir_program, :use_combinator
 
-    def initialize(source, use_combinator: true)
+    def initialize(source, use_combinator: true, 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
+      @body_parser = BodyParser.new if parse_body
       @ir_program = nil
     end
 
@@ -21,6 +29,7 @@ module TRuby
       functions = []
       type_aliases = []
       interfaces = []
+      classes = []
       i = 0
 
       while i < @lines.length
@@ -42,10 +51,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*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,6 +79,7 @@ module TRuby
         functions: functions,
         type_aliases: type_aliases,
         interfaces: interfaces,
+        classes: classes,
       }
 
       # Build IR if combinator is enabled
@@ -83,6 +107,41 @@ module TRuby
 
     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
@@ -109,11 +168,16 @@ 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
+      match = line.match(/^\s*def\s+(#{METHOD_NAME_PATTERN})\s*(?:\((.*?)\))?\s*(?::\s*(.+?))?\s*$/)
       return nil unless match
 
       function_name = match[1]
-      params_str = match[2]
+      params_str = match[2] || ""
       return_type_str = match[3]&.strip
 
       # Validate return type if present
@@ -231,6 +295,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*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:]+)/)

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