t-ruby 0.0.42 → 0.0.43

data/lib/t_ruby/parser.rb

@@ -15,6 +15,9 @@ module TRuby
     # Visibility modifiers for method definitions
     VISIBILITY_PATTERN = '(?:(?:private|protected|public)\s+)?'
 
+    # TODO: Replace regex-based parsing with TokenDeclarationParser
+    # See: lib/t_ruby/parser_combinator/token/token_declaration_parser.rb
+
     attr_reader :source, :ir_program
 
     def initialize(source, parse_body: true)
@@ -22,7 +25,7 @@ module TRuby
       @lines = source.split("\n")
       @parse_body = parse_body
       @type_parser = ParserCombinator::TypeParser.new
-      @body_parser = BodyParser.new if parse_body
+      @body_parser = ParserCombinator::TokenBodyParser.new if parse_body
       @ir_program = nil
     end
 
@@ -97,6 +100,8 @@ module TRuby
       @ir_program = builder.build(result, source: @source)
 
       result
+    rescue Scanner::ScanError => e
+      raise ParseError.new(e.message, line: e.line, column: e.column)
     end
 
     # Parse to IR directly (new API)
@@ -116,10 +121,14 @@ module TRuby
     # 최상위 함수를 본문까지 포함하여 파싱
     def parse_function_with_body(start_index)
       line = @lines[start_index]
-      func_info = parse_function_definition(line)
+      func_info = parse_function_definition(line, line_number: start_index + 1)
       return [nil, start_index] unless func_info
 
+      # Add location info (1-based line number, column is 1 + indentation)
       def_indent = line.match(/^(\s*)/)[1].length
+      func_info[:line] = start_index + 1
+      func_info[:column] = def_indent + 1
+
       i = start_index + 1
       body_start = i
       body_end = i
@@ -171,13 +180,14 @@ module TRuby
       }
     end
 
-    def parse_function_definition(line)
+    def parse_function_definition(line, line_number: 1) # rubocop:disable Lint/UnusedMethodArgument
       # 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
 
@@ -547,10 +557,14 @@ module TRuby
     # 클래스 내부의 메서드를 본문까지 포함하여 파싱
     def parse_method_in_class(start_index, class_end)
       line = @lines[start_index]
-      method_info = parse_function_definition(line)
+      method_info = parse_function_definition(line, line_number: start_index + 1)
       return [nil, start_index] unless method_info
 
+      # Add location info (1-based line number, column is 1 + indentation)
       def_indent = line.match(/^(\s*)/)[1].length
+      method_info[:line] = start_index + 1
+      method_info[:column] = def_indent + 1
+
       i = start_index + 1
       body_start = i
       body_end = i

data/lib/t_ruby/parser_combinator/combinators/alternative.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module TRuby
+  module ParserCombinator
+    # Alternative: try first, if fails try second
+    class Alternative < Parser
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      def parse(input, position = 0)
+        result = @left.parse(input, position)
+        return result if result.success?
+
+        @right.parse(input, position)
+      end
+    end
+  end
+end

data/lib/t_ruby/parser_combinator/combinators/chain_left.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module TRuby
+  module ParserCombinator
+    # Chainl: left-associative chain
+    class ChainLeft < Parser
+      def initialize(term, op)
+        @term = term
+        @op = op
+      end
+
+      def parse(input, position = 0)
+        first = @term.parse(input, position)
+        return first if first.failure?
+
+        result = first.value
+        current_pos = first.position
+
+        loop do
+          op_result = @op.parse(input, current_pos)
+          break if op_result.failure?
+
+          term_result = @term.parse(input, op_result.position)
+          break if term_result.failure?
+
+          result = op_result.value.call(result, term_result.value)
+          current_pos = term_result.position
+        end
+
+        ParseResult.success(result, input, current_pos)
+      end
+    end
+  end
+end

data/lib/t_ruby/parser_combinator/combinators/choice.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module TRuby
+  module ParserCombinator
+    # Choice: try multiple parsers in order
+    class Choice < Parser
+      def initialize(*parsers)
+        @parsers = parsers
+      end
+
+      def parse(input, position = 0)
+        best_error = nil
+        best_position = position
+
+        @parsers.each do |parser|
+          result = parser.parse(input, position)
+          return result if result.success?
+
+          if result.position >= best_position
+            best_error = result.error
+            best_position = result.position
+          end
+        end
+
+        ParseResult.failure(best_error || "No alternative matched", input, best_position)
+      end
+    end
+  end
+end

data/lib/t_ruby/parser_combinator/combinators/flat_map.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module TRuby
+  module ParserCombinator
+    # FlatMap (bind)
+    class FlatMap < Parser
+      def initialize(parser, func)
+        @parser = parser
+        @func = func
+      end
+
+      def parse(input, position = 0)
+        result = @parser.parse(input, position)
+        return result if result.failure?
+
+        next_parser = @func.call(result.value)
+        next_parser.parse(input, result.position)
+      end
+    end
+  end
+end

data/lib/t_ruby/parser_combinator/combinators/label.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module TRuby
+  module ParserCombinator
+    # Label for error messages
+    class Label < Parser
+      def initialize(parser, name)
+        @parser = parser
+        @name = name
+      end
+
+      def parse(input, position = 0)
+        result = @parser.parse(input, position)
+        if result.failure?
+          ParseResult.failure("Expected #{@name}", input, position)
+        else
+          result
+        end
+      end
+    end
+  end
+end

data/lib/t_ruby/parser_combinator/combinators/lookahead.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module TRuby
+  module ParserCombinator
+    # Lookahead: check without consuming
+    class Lookahead < Parser
+      def initialize(parser)
+        @parser = parser
+      end
+
+      def parse(input, position = 0)
+        result = @parser.parse(input, position)
+        if result.success?
+          ParseResult.success(result.value, input, position)
+        else
+          result
+        end
+      end
+    end
+  end
+end

data/lib/t_ruby/parser_combinator/combinators/many.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module TRuby
+  module ParserCombinator
+    # Many: zero or more
+    class Many < Parser
+      def initialize(parser)
+        @parser = parser
+      end
+
+      def parse(input, position = 0)
+        results = []
+        current_pos = position
+
+        loop do
+          result = @parser.parse(input, current_pos)
+          break if result.failure?
+
+          results << result.value
+          break if result.position == current_pos # Prevent infinite loop
+
+          current_pos = result.position
+        end
+
+        ParseResult.success(results, input, current_pos)
+      end
+    end
+  end
+end

data/lib/t_ruby/parser_combinator/combinators/many1.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module TRuby
+  module ParserCombinator
+    # Many1: one or more
+    class Many1 < Parser
+      def initialize(parser)
+        @parser = parser
+      end
+
+      def parse(input, position = 0)
+        first = @parser.parse(input, position)
+        return first if first.failure?
+
+        results = [first.value]
+        current_pos = first.position
+
+        loop do
+          result = @parser.parse(input, current_pos)
+          break if result.failure?
+
+          results << result.value
+          break if result.position == current_pos
+
+          current_pos = result.position
+        end
+
+        ParseResult.success(results, input, current_pos)
+      end
+    end
+  end
+end

data/lib/t_ruby/parser_combinator/combinators/map.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module TRuby
+  module ParserCombinator
+    # Map result
+    class Map < Parser
+      def initialize(parser, func)
+        @parser = parser
+        @func = func
+      end
+
+      def parse(input, position = 0)
+        @parser.parse(input, position).map(&@func)
+      end
+    end
+  end
+end

data/lib/t_ruby/parser_combinator/combinators/not_followed_by.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module TRuby
+  module ParserCombinator
+    # Not followed by
+    class NotFollowedBy < Parser
+      def initialize(parser)
+        @parser = parser
+      end
+
+      def parse(input, position = 0)
+        result = @parser.parse(input, position)
+        if result.failure?
+          ParseResult.success(nil, input, position)
+        else
+          ParseResult.failure("Unexpected match", input, position)
+        end
+      end
+    end
+  end
+end

data/lib/t_ruby/parser_combinator/combinators/optional.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module TRuby
+  module ParserCombinator
+    # Optional: zero or one
+    class Optional < Parser
+      def initialize(parser)
+        @parser = parser
+      end
+
+      def parse(input, position = 0)
+        result = @parser.parse(input, position)
+        if result.success?
+          result
+        else
+          ParseResult.success(nil, input, position)
+        end
+      end
+    end
+  end
+end

data/lib/t_ruby/parser_combinator/combinators/sep_by.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module TRuby
+  module ParserCombinator
+    # Separated by delimiter
+    class SepBy < Parser
+      def initialize(parser, delimiter)
+        @parser = parser
+        @delimiter = delimiter
+      end
+
+      def parse(input, position = 0)
+        first = @parser.parse(input, position)
+        return ParseResult.success([], input, position) if first.failure?
+
+        results = [first.value]
+        current_pos = first.position
+
+        loop do
+          delim_result = @delimiter.parse(input, current_pos)
+          break if delim_result.failure?
+
+          item_result = @parser.parse(input, delim_result.position)
+          break if item_result.failure?
+
+          results << item_result.value
+          current_pos = item_result.position
+        end
+
+        ParseResult.success(results, input, current_pos)
+      end
+    end
+  end
+end

data/lib/t_ruby/parser_combinator/combinators/sep_by1.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module TRuby
+  module ParserCombinator
+    # Separated by 1 (at least one)
+    class SepBy1 < Parser
+      def initialize(parser, delimiter)
+        @parser = parser
+        @delimiter = delimiter
+      end
+
+      def parse(input, position = 0)
+        first = @parser.parse(input, position)
+        return first if first.failure?
+
+        results = [first.value]
+        current_pos = first.position
+
+        loop do
+          delim_result = @delimiter.parse(input, current_pos)
+          break if delim_result.failure?
+
+          item_result = @parser.parse(input, delim_result.position)
+          break if item_result.failure?
+
+          results << item_result.value
+          current_pos = item_result.position
+        end
+
+        ParseResult.success(results, input, current_pos)
+      end
+    end
+  end
+end

data/lib/t_ruby/parser_combinator/combinators/sequence.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module TRuby
+  module ParserCombinator
+    # Sequence two parsers
+    class Sequence < Parser
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      def parse(input, position = 0)
+        result1 = @left.parse(input, position)
+        return result1 if result1.failure?
+
+        result2 = @right.parse(input, result1.position)
+        return result2 if result2.failure?
+
+        ParseResult.success([result1.value, result2.value], input, result2.position)
+      end
+    end
+  end
+end

data/lib/t_ruby/parser_combinator/combinators/skip_right.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module TRuby
+  module ParserCombinator
+    # Skip right: parse both, return left
+    class SkipRight < Parser
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      def parse(input, position = 0)
+        result1 = @left.parse(input, position)
+        return result1 if result1.failure?
+
+        result2 = @right.parse(input, result1.position)
+        return result2 if result2.failure?
+
+        ParseResult.success(result1.value, input, result2.position)
+      end
+    end
+  end
+end

data/lib/t_ruby/parser_combinator/declaration_parser.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module TRuby
+  module ParserCombinator
+    # Declaration Parser - Parse T-Ruby declarations
+    class DeclarationParser
+      include DSL
+
+      def initialize
+        @type_parser = TypeParser.new
+        build_parsers
+      end
+
+      def parse(input)
+        result = @declaration.parse(input.strip)
+        if result.success?
+          { success: true, declarations: result.value }
+        else
+          { success: false, error: result.error, position: result.position }
+        end
+      end
+
+      def parse_file(input)
+        result = @program.parse(input)
+        if result.success?
+          { success: true, declarations: result.value.compact }
+        else
+          { success: false, error: result.error, position: result.position }
+        end
+      end
+
+      private
+
+      def build_parsers
+        # Type expression (delegate to TypeParser)
+        lazy { parse_type_inline }
+
+        # Keywords
+        kw_type = lexeme(string("type"))
+        kw_interface = lexeme(string("interface"))
+        kw_def = lexeme(string("def"))
+        kw_end = lexeme(string("end"))
+        lexeme(string("class"))
+        lexeme(string("module"))
+
+        # Type alias: type Name = Definition
+        type_alias = (
+          kw_type >>
+          lexeme(identifier) <<
+          lexeme(char("=")) >>
+          regex(/[^\n]+/).map(&:strip)
+        ).map do |((_, name), definition)|
+          type_result = @type_parser.parse(definition)
+          if type_result[:success]
+            IR::TypeAlias.new(name: name, definition: type_result[:type])
+          end
+        end
+
+        # Interface member: name: Type
+        interface_member = (
+          lexeme(identifier) <<
+          lexeme(char(":")) >>
+          regex(/[^\n]+/).map(&:strip)
+        ).map do |(name, type_str)|
+          type_result = @type_parser.parse(type_str)
+          if type_result[:success]
+            IR::InterfaceMember.new(name: name, type_signature: type_result[:type])
+          end
+        end
+
+        # Interface: interface Name ... end
+        interface_body = (interface_member << (newline | spaces)).many
+
+        interface_decl = (
+          kw_interface >>
+          lexeme(identifier) <<
+          (newline | spaces) >>
+          interface_body <<
+          kw_end
+        ).map do |((_, name), members)|
+          IR::Interface.new(name: name, members: members.compact)
+        end
+
+        # Parameter: name: Type or name
+        param = (
+          identifier >>
+          (lexeme(char(":")) >> regex(/[^,)]+/).map(&:strip)).optional
+        ).map do |(name, type_str)|
+          type_node = if type_str
+                        type_str_val = type_str.is_a?(Array) ? type_str.last : type_str
+                        result = @type_parser.parse(type_str_val)
+                        result[:success] ? result[:type] : nil
+                      end
+          IR::Parameter.new(name: name, type_annotation: type_node)
+        end
+
+        # Parameters list
+        params_list = (
+          lexeme(char("(")) >>
+          param.sep_by(lexeme(char(","))) <<
+          lexeme(char(")"))
+        ).map { |(_, params)| params }
+
+        # Return type annotation
+        return_type = (
+          lexeme(char(":")) >>
+          regex(/[^\n]+/).map(&:strip)
+        ).map { |(_, type_str)| type_str }.optional
+
+        # Method definition: def name(params): ReturnType
+        method_def = (
+          kw_def >>
+          identifier >>
+          params_list.optional >>
+          return_type
+        ).map do |(((_, name), params), ret_str)|
+          ret_type = if ret_str
+                       result = @type_parser.parse(ret_str)
+                       result[:success] ? result[:type] : nil
+                     end
+          IR::MethodDef.new(
+            name: name,
+            params: params || [],
+            return_type: ret_type
+          )
+        end
+
+        # Any declaration
+        @declaration = choice(
+          type_alias,
+          interface_decl,
+          method_def
+        )
+
+        # Line (declaration or empty)
+        line = (@declaration << (newline | eof)) | (spaces >> newline).map { nil }
+
+        # Program (multiple declarations)
+        @program = line.many
+      end
+
+      def parse_type_inline
+        Lazy.new { @type_parser.instance_variable_get(:@type_expr) }
+      end
+    end
+  end
+end