t-ruby 0.0.42 → 0.0.43

data/lib/t_ruby/parser_combinator/token/token_dsl.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module TRuby
+  module ParserCombinator
+    # Token DSL Module - Convenience methods for token parsing
+    module TokenDSL
+      def token(type)
+        TokenMatcher.new(type)
+      end
+
+      def keyword(kw)
+        TokenMatcher.new(kw)
+      end
+    end
+  end
+end

data/lib/t_ruby/parser_combinator/token/token_label.rb

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

data/lib/t_ruby/parser_combinator/token/token_many.rb

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

data/lib/t_ruby/parser_combinator/token/token_many1.rb

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

data/lib/t_ruby/parser_combinator/token/token_map.rb

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

data/lib/t_ruby/parser_combinator/token/token_matcher.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module TRuby
+  module ParserCombinator
+    # Match a specific token type
+    class TokenMatcher < TokenParser
+      def initialize(token_type)
+        @token_type = token_type
+      end
+
+      def parse(tokens, position = 0)
+        return TokenParseResult.failure("End of input", tokens, position) if position >= tokens.length
+
+        token = tokens[position]
+        return TokenParseResult.failure("End of input", tokens, position) if token.type == :eof
+
+        if token.type == @token_type
+          TokenParseResult.success(token, tokens, position + 1)
+        else
+          TokenParseResult.failure(
+            "Expected :#{@token_type}, got :#{token.type} (#{token.value.inspect})",
+            tokens,
+            position
+          )
+        end
+      end
+    end
+  end
+end

data/lib/t_ruby/parser_combinator/token/token_optional.rb

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

data/lib/t_ruby/parser_combinator/token/token_parse_result.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module TRuby
+  module ParserCombinator
+    # Token-based parse result
+    class TokenParseResult
+      attr_reader :value, :tokens, :position, :error
+
+      def initialize(success:, value: nil, tokens: [], position: 0, error: nil)
+        @success = success
+        @value = value
+        @tokens = tokens
+        @position = position
+        @error = error
+      end
+
+      def success?
+        @success
+      end
+
+      def failure?
+        !@success
+      end
+
+      def self.success(value, tokens, position)
+        new(success: true, value: value, tokens: tokens, position: position)
+      end
+
+      def self.failure(error, tokens, position)
+        new(success: false, error: error, tokens: tokens, position: position)
+      end
+
+      def map
+        return self if failure?
+
+        TokenParseResult.success(yield(value), tokens, position)
+      end
+    end
+  end
+end

data/lib/t_ruby/parser_combinator/token/token_parser.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module TRuby
+  module ParserCombinator
+    # Base class for token parsers
+    class TokenParser
+      def parse(tokens, position = 0)
+        raise NotImplementedError
+      end
+
+      # Sequence: run this parser, then the other
+      def >>(other)
+        TokenSequence.new(self, other)
+      end
+
+      # Alternative: try this parser, if it fails try the other
+      def |(other)
+        TokenAlternative.new(self, other)
+      end
+
+      # Map: transform the result
+      def map(&block)
+        TokenMap.new(self, block)
+      end
+
+      # Many: zero or more repetitions
+      def many
+        TokenMany.new(self)
+      end
+
+      # Many1: one or more repetitions
+      def many1
+        TokenMany1.new(self)
+      end
+
+      # Optional: zero or one
+      def optional
+        TokenOptional.new(self)
+      end
+
+      # Separated by: parse items separated by delimiter
+      def sep_by(delimiter)
+        TokenSepBy.new(self, delimiter)
+      end
+
+      # Separated by 1: at least one item
+      def sep_by1(delimiter)
+        TokenSepBy1.new(self, delimiter)
+      end
+
+      # Skip right: parse both, keep left result
+      def <<(other)
+        TokenSkipRight.new(self, other)
+      end
+
+      # Label: add a descriptive label for error messages
+      def label(name)
+        TokenLabel.new(self, name)
+      end
+    end
+  end
+end

data/lib/t_ruby/parser_combinator/token/token_sep_by.rb

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

data/lib/t_ruby/parser_combinator/token/token_sep_by1.rb

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

data/lib/t_ruby/parser_combinator/token/token_sequence.rb

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

data/lib/t_ruby/parser_combinator/token/token_skip_right.rb

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

data/lib/t_ruby/parser_combinator/type_parser.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module TRuby
+  module ParserCombinator
+    # Type Parser - Parse T-Ruby type expressions
+    class TypeParser
+      include DSL
+
+      def initialize
+        build_parsers
+      end
+
+      def parse(input)
+        result = @type_expr.parse(input.strip)
+        if result.success?
+          { success: true, type: result.value, remaining: input[result.position..] }
+        else
+          { success: false, error: result.error, position: result.position }
+        end
+      end
+
+      private
+
+      def build_parsers
+        # Identifier (type name)
+        type_name = identifier.label("type name")
+
+        # Simple type
+        type_name.map { |name| IR::SimpleType.new(name: name) }
+
+        # Lazy reference for recursive types
+        type_expr = lazy { @type_expr }
+
+        # Generic type arguments: <Type, Type, ...>
+        generic_args = (
+          lexeme(char("<")) >>
+          type_expr.sep_by1(lexeme(char(","))) <<
+          lexeme(char(">"))
+        ).map { |(_, types)| types }
+
+        # Generic type: Base<Args>
+        generic_type = (type_name >> generic_args.optional).map do |(name, args)|
+          if args && !args.empty?
+            IR::GenericType.new(base: name, type_args: args)
+          else
+            IR::SimpleType.new(name: name)
+          end
+        end
+
+        # Nullable type: Type?
+        nullable_suffix = char("?")
+
+        # Parenthesized type
+        paren_type = (lexeme(char("(")) >> type_expr << lexeme(char(")"))).map { |(_, t)| t }
+
+        # Function type: (Params) -> ReturnType
+        param_list = (
+          lexeme(char("(")) >>
+          type_expr.sep_by(lexeme(char(","))) <<
+          lexeme(char(")"))
+        ).map { |(_, params)| params }
+
+        arrow = lexeme(string("->"))
+
+        function_type = (param_list >> arrow >> type_expr).map do |((params, _arrow), ret)|
+          IR::FunctionType.new(param_types: params, return_type: ret)
+        end
+
+        # Tuple type: [Type, Type, ...]
+        tuple_type = (
+          lexeme(char("[")) >>
+          type_expr.sep_by1(lexeme(char(","))) <<
+          lexeme(char("]"))
+        ).map { |(_, types)| IR::TupleType.new(element_types: types) }
+
+        # Primary type (before operators)
+        primary_type = choice(
+          function_type,
+          tuple_type,
+          paren_type,
+          generic_type
+        )
+
+        # With optional nullable suffix
+        base_type = (primary_type >> nullable_suffix.optional).map do |(type, nullable)|
+          nullable ? IR::NullableType.new(inner_type: type) : type
+        end
+
+        # Union type: Type | Type | ...
+        union_op = lexeme(char("|"))
+        union_type = base_type.sep_by1(union_op).map do |types|
+          types.length == 1 ? types.first : IR::UnionType.new(types: types)
+        end
+
+        # Intersection type: Type & Type & ...
+        intersection_op = lexeme(char("&"))
+        @type_expr = union_type.sep_by1(intersection_op).map do |types|
+          types.length == 1 ? types.first : IR::IntersectionType.new(types: types)
+        end
+      end
+    end
+  end
+end