t-ruby 0.0.42 → 0.0.46

data/lib/t_ruby/ir.rb

@@ -234,6 +234,20 @@ module TRuby
       end
     end
 
+    # Interpolated string (string with #{...} expressions)
+    class InterpolatedString < Node
+      attr_accessor :parts
+
+      def initialize(parts: [], **opts)
+        super(**opts)
+        @parts = parts
+      end
+
+      def children
+        @parts
+      end
+    end
+
     # Array literal
     class ArrayLiteral < Node
       attr_accessor :elements, :element_type
@@ -632,7 +646,13 @@ module TRuby
       end
 
       def to_rbs
-        "#{@inner_type.to_rbs}?"
+        inner_rbs = @inner_type.to_rbs
+        # Simple types can use ? suffix, complex types need (Type | nil) form
+        if @inner_type.is_a?(SimpleType)
+          "#{inner_rbs}?"
+        else
+          "(#{inner_rbs} | nil)"
+        end
       end
 
       def to_trb
@@ -658,6 +678,26 @@ module TRuby
       end
     end
 
+    # Hash literal type: { key: Type, key2: Type }
+    class HashLiteralType < TypeNode
+      attr_accessor :fields # Array of { name: String, type: TypeNode }
+
+      def initialize(fields:, **opts)
+        super(**opts)
+        @fields = fields
+      end
+
+      def to_rbs
+        # Hash literal types in RBS are represented as Hash[Symbol, untyped] or specific record types
+        "Hash[Symbol, untyped]"
+      end
+
+      def to_trb
+        field_strs = @fields.map { |f| "#{f[:name]}: #{f[:type].to_trb}" }
+        "{ #{field_strs.join(", ")} }"
+      end
+    end
+
     #==========================================================================
     # Visitor Pattern
     #==========================================================================
@@ -778,12 +818,16 @@ module TRuby
         # 본문 IR이 있으면 사용 (BodyParser에서 파싱됨)
         body = info[:body_ir]
 
+        # Build location string from line/column info
+        location = info[:line] && info[:column] ? "#{info[:line]}:#{info[:column]}" : nil
+
         MethodDef.new(
           name: info[:name],
           params: params,
           return_type: info[:return_type] ? parse_type(info[:return_type]) : nil,
           body: body,
-          visibility: info[:visibility] || :public
+          visibility: info[:visibility] || :public,
+          location: location
         )
       end
 
@@ -791,77 +835,17 @@ module TRuby
         return nil unless type_str
 
         type_str = type_str.strip
+        return nil if type_str.empty?
 
-        # Union type
-        if type_str.include?("|")
-          types = type_str.split("|").map { |t| parse_type(t.strip) }
-          return UnionType.new(types: types)
-        end
-
-        # Intersection type
-        if type_str.include?("&")
-          types = type_str.split("&").map { |t| parse_type(t.strip) }
-          return IntersectionType.new(types: types)
-        end
-
-        # Nullable type
-        if type_str.end_with?("?")
-          inner = parse_type(type_str[0..-2])
-          return NullableType.new(inner_type: inner)
-        end
-
-        # Generic type
-        if type_str.include?("<") && type_str.include?(">")
-          match = type_str.match(/^(\w+)<(.+)>$/)
-          if match
-            base = match[1]
-            args = parse_generic_args(match[2])
-            return GenericType.new(base: base, type_args: args)
-          end
-        end
-
-        # Function type
-        if type_str.include?("->")
-          match = type_str.match(/^\((.*)?\)\s*->\s*(.+)$/)
-          if match
-            param_types = match[1] ? match[1].split(",").map { |t| parse_type(t.strip) } : []
-            return_type = parse_type(match[2])
-            return FunctionType.new(param_types: param_types, return_type: return_type)
-          end
-        end
+        # Use ParserCombinator::TypeParser for all type parsing
+        # Supports: simple types, generics, array shorthand, union, intersection, function types
+        @type_parser ||= TRuby::ParserCombinator::TypeParser.new
+        result = @type_parser.parse(type_str)
+        return result[:type] if result[:success]
 
-        # Simple type
+        # Fallback for unparseable types - return as SimpleType
         SimpleType.new(name: type_str)
       end
-
-      def parse_generic_args(args_str)
-        args = []
-        current = ""
-        depth = 0
-
-        args_str.each_char do |char|
-          case char
-          when "<"
-            depth += 1
-            current += char
-          when ">"
-            depth -= 1
-            current += char
-          when ","
-            if depth.zero?
-              args << parse_type(current.strip)
-              current = ""
-            else
-              current += char
-            end
-          else
-            current += char
-          end
-        end
-
-        args << parse_type(current.strip) unless current.empty?
-        args
-      end
     end
 
     #==========================================================================

data/lib/t_ruby/lsp_server.rb

@@ -122,6 +122,8 @@ module TRuby
       @initialized = false
       @shutdown_requested = false
       @type_alias_registry = TypeAliasRegistry.new
+      # Use Compiler for unified diagnostics (same as CLI)
+      @compiler = Compiler.new
     end
 
     # Main run loop for the LSP server
@@ -368,114 +370,55 @@ module TRuby
                         })
     end
 
-    def analyze_document(text)
-      diagnostics = []
+    def analyze_document(text, uri: nil)
+      # Use unified Compiler.analyze for diagnostics
+      # This ensures CLI and LSP show the same errors
+      file_path = uri ? uri_to_path(uri) : "<source>"
+      compiler_diagnostics = @compiler.analyze(text, file: file_path)
 
-      # Use ErrorHandler to check for errors
-      error_handler = ErrorHandler.new(text)
-      errors = error_handler.check
-
-      errors.each do |error|
-        # Parse line number from error message
-        next unless error =~ /^Line (\d+):\s*(.+)$/
-
-        line_num = Regexp.last_match(1).to_i - 1 # LSP uses 0-based line numbers
-        message = Regexp.last_match(2)
-
-        diagnostics << create_diagnostic(line_num, message, DiagnosticSeverity::ERROR)
-      end
-
-      # Additional validation using Parser
-      begin
-        parser = Parser.new(text)
-        result = parser.parse
-
-        # Validate type aliases
-        validate_type_aliases(result[:type_aliases] || [], diagnostics, text)
-
-        # Validate function types
-        validate_functions(result[:functions] || [], diagnostics, text)
-      rescue StandardError => e
-        diagnostics << create_diagnostic(0, "Parse error: #{e.message}", DiagnosticSeverity::ERROR)
-      end
-
-      diagnostics
+      # Convert TRuby::Diagnostic objects to LSP diagnostic format
+      compiler_diagnostics.map { |d| diagnostic_to_lsp(d) }
     end
 
-    def validate_type_aliases(type_aliases, diagnostics, text)
-      lines = text.split("\n")
-      registry = TypeAliasRegistry.new
-
-      type_aliases.each do |alias_info|
-        line_num = find_line_number(lines, /^\s*type\s+#{Regexp.escape(alias_info[:name])}\s*=/)
-        next unless line_num
-
-        begin
-          registry.register(alias_info[:name], alias_info[:definition])
-        rescue DuplicateTypeAliasError => e
-          diagnostics << create_diagnostic(line_num, e.message, DiagnosticSeverity::ERROR)
-        rescue CircularTypeAliasError => e
-          diagnostics << create_diagnostic(line_num, e.message, DiagnosticSeverity::ERROR)
-        end
-      end
-    end
+    # Convert TRuby::Diagnostic to LSP diagnostic format
+    def diagnostic_to_lsp(diagnostic)
+      # LSP uses 0-based line numbers
+      line = (diagnostic.line || 1) - 1
+      line = 0 if line.negative?
 
-    def validate_functions(functions, diagnostics, text)
-      lines = text.split("\n")
+      col = (diagnostic.column || 1) - 1
+      col = 0 if col.negative?
 
-      functions.each do |func|
-        line_num = find_line_number(lines, /^\s*def\s+#{Regexp.escape(func[:name])}\s*\(/)
-        next unless line_num
-
-        # Validate return type
-        if func[:return_type] && !valid_type?(func[:return_type])
-          diagnostics << create_diagnostic(
-            line_num,
-            "Unknown return type '#{func[:return_type]}'",
-            DiagnosticSeverity::WARNING
-          )
-        end
-
-        # Validate parameter types
-        func[:params]&.each do |param|
-          next unless param[:type] && !valid_type?(param[:type])
-
-          diagnostics << create_diagnostic(
-            line_num,
-            "Unknown parameter type '#{param[:type]}' for '#{param[:name]}'",
-            DiagnosticSeverity::WARNING
-          )
-        end
-      end
-    end
+      end_col = diagnostic.end_column ? diagnostic.end_column - 1 : col + 1
 
-    def find_line_number(lines, pattern)
-      lines.each_with_index do |line, idx|
-        return idx if line.match?(pattern)
-      end
-      nil
-    end
+      severity = case diagnostic.severity
+                 when :error then DiagnosticSeverity::ERROR
+                 when :warning then DiagnosticSeverity::WARNING
+                 when :info then DiagnosticSeverity::INFORMATION
+                 else DiagnosticSeverity::ERROR
+                 end
 
-    def valid_type?(type_str)
-      return true if type_str.nil?
+      lsp_diag = {
+        "range" => {
+          "start" => { "line" => line, "character" => col },
+          "end" => { "line" => line, "character" => end_col },
+        },
+        "severity" => severity,
+        "source" => "t-ruby",
+        "message" => diagnostic.message,
+      }
 
-      # Handle union types
-      if type_str.include?("|")
-        return type_str.split("|").map(&:strip).all? { |t| valid_type?(t) }
-      end
+      # Add error code if available
+      lsp_diag["code"] = diagnostic.code if diagnostic.code
 
-      # Handle intersection types
-      if type_str.include?("&")
-        return type_str.split("&").map(&:strip).all? { |t| valid_type?(t) }
-      end
+      lsp_diag
+    end
 
-      # Handle generic types
-      if type_str.include?("<")
-        base_type = type_str.split("<").first
-        return BUILT_IN_TYPES.include?(base_type) || @type_alias_registry.valid_type?(base_type)
-      end
+    def uri_to_path(uri)
+      # Convert file:// URI to filesystem path
+      return uri unless uri.start_with?("file://")
 
-      BUILT_IN_TYPES.include?(type_str) || @type_alias_registry.valid_type?(type_str)
+      uri.sub(%r{^file://}, "")
     end
 
     def create_diagnostic(line, message, severity)

data/lib/t_ruby/package_manager.rb

@@ -4,6 +4,7 @@ require "json"
 require "fileutils"
 require "net/http"
 require "uri"
+require "time"
 
 module TRuby
   # Semantic version parsing and comparison

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