t-ruby 0.0.42 → 0.0.43

data/lib/t_ruby/error_handler.rb

@@ -2,7 +2,9 @@
 
 module TRuby
   class ErrorHandler
-    VALID_TYPES = %w[String Integer Boolean Array Hash Symbol void nil].freeze
+    VALID_TYPES = %w[String Integer Float Boolean Array Hash Symbol void nil].freeze
+    # Unicode-aware identifier pattern for method/variable names (supports Korean, etc.)
+    IDENTIFIER_PATTERN = /[\w\p{L}\p{N}]+[!?]?/
 
     def initialize(source)
       @source = source
@@ -97,34 +99,76 @@ module TRuby
       end
 
       # Pattern 2: Check for text after closing paren without colon (e.g., "def test() something")
-      if (match = line.match(/def\s+\w+\s*\([^)]*\)\s*([^:\s].+?)\s*$/))
-        trailing = match[1].strip
-        # Allow if it's just end-of-line content or a valid Ruby block start
-        unless trailing.empty? || trailing.start_with?("#") || trailing == "end"
-          @errors << "Line #{idx + 1}: Unexpected token '#{trailing}' after method parameters - did you forget ':'?"
+      # Use balanced paren matching to find the correct closing paren
+      params_end = find_params_closing_paren(line)
+      if params_end
+        after_params = line[params_end..].strip
+        # Check if there's trailing content that's not a return type annotation
+        if (match = after_params.match(/^\)\s*([^:\s].+?)\s*$/))
+          trailing = match[1].strip
+          # Allow if it's just end-of-line content or a valid Ruby block start
+          unless trailing.empty? || trailing.start_with?("#") || trailing == "end"
+            @errors << "Line #{idx + 1}: Unexpected token '#{trailing}' after method parameters - did you forget ':'?"
+          end
+          return
         end
-        return
       end
 
       # Pattern 3: Check for parameter with colon but no type (e.g., "def test(x:)")
-      if line.match?(/def\s+\w+\s*\([^)]*\w+:\s*[,)]/)
+      # Skip this check for keyword args group { name:, age: } - they're valid
+      params_str = extract_params_string(line)
+      # Check each parameter for colon without type
+      # Match: "x:" at end, "x:," in middle, or "x: )" with space before closing
+      if params_str && !params_str.include?("{") &&
+         (params_str.match?(/\w+:\s*$/) || params_str.match?(/\w+:\s*,/))
         @errors << "Line #{idx + 1}: Expected type after parameter colon"
         return
       end
 
       # Pattern 4: Extract and validate return type
-      if (match = line.match(/def\s+\w+\s*\([^)]*\)\s*:\s*(.+?)\s*$/))
-        return_type_str = match[1].strip
-        validate_type_expression(return_type_str, idx, "return type")
+      if params_end
+        after_params = line[params_end..]
+        if (match = after_params.match(/\)\s*:\s*(.+?)\s*$/))
+          return_type_str = match[1].strip
+          validate_type_expression(return_type_str, idx, "return type")
+        end
       end
 
       # Pattern 5: Extract and validate parameter types
-      if (match = line.match(/def\s+\w+\s*\(([^)]+)\)/))
-        params_str = match[1]
+      if params_str
         validate_parameter_types_expression(params_str, idx)
       end
     end
 
+    # Find the position of the closing paren for method parameters (balanced matching)
+    def find_params_closing_paren(line)
+      start_pos = line.index("(")
+      return nil unless start_pos
+
+      depth = 0
+      line[start_pos..].each_char.with_index do |char, i|
+        case char
+        when "("
+          depth += 1
+        when ")"
+          depth -= 1
+          return start_pos + i if depth.zero?
+        end
+      end
+      nil
+    end
+
+    # Extract the parameters string from a method definition line
+    def extract_params_string(line)
+      start_pos = line.index("(")
+      return nil unless start_pos
+
+      end_pos = find_params_closing_paren(line)
+      return nil unless end_pos
+
+      line[(start_pos + 1)...end_pos]
+    end
+
     def validate_type_expression(type_str, line_idx, context = "type")
       return if type_str.nil? || type_str.empty?
 
@@ -153,7 +197,9 @@ module TRuby
       end
 
       # Check for unclosed brackets
-      if type_str.count("<") != type_str.count(">")
+      # Note: we need to exclude -> arrow operators when counting < and >
+      angle_balance = count_angle_brackets(type_str)
+      if angle_balance != 0
         @errors << "Line #{line_idx + 1}: Invalid #{context} '#{type_str}' - unbalanced angle brackets"
         return
       end
@@ -189,12 +235,17 @@ module TRuby
       # Check for extra tokens after valid type (e.g., "String something_else")
       # Use TypeParser to validate
       result = @type_parser.parse(type_str)
-      if result[:success]
-        remaining = type_str[(result[:position] || 0)..]&.strip
-        if remaining && !remaining.empty? && result[:remaining] && !result[:remaining].strip.empty?
-          @errors << "Line #{line_idx + 1}: Unexpected token after #{context} '#{type_str}'"
-        end
-      end
+      return unless result[:success]
+
+      remaining = result[:remaining]&.strip
+      return if remaining.nil? || remaining.empty?
+
+      # Allow RBS-style square bracket generics (e.g., Hash[Symbol, String])
+      # Allow nullable suffix (e.g., String?)
+      # Allow array suffix (e.g., [])
+      return if remaining.start_with?("[") || remaining.start_with?("?") || remaining == "[]"
+
+      @errors << "Line #{line_idx + 1}: Unexpected token after #{context} '#{type_str}'"
     end
 
     def validate_parameter_types_expression(params_str, line_idx)
@@ -207,36 +258,104 @@ module TRuby
         param = param.strip
         next if param.empty?
 
-        # Check for param: Type pattern
+        # Skip keyword args group: { name: Type, age: Type }
+        next if param.start_with?("{")
+
+        # Skip block parameter: &block or &block: Type
+        next if param.start_with?("&")
+
+        # Skip rest parameter: *args or *args: Type
+        next if param.start_with?("*")
+
+        # Check for param: Type pattern (with optional default value)
+        # Match: name: Type or name: Type = default
         next unless (match = param.match(/^(\w+)\s*:\s*(.+)$/))
 
         param_name = match[1]
-        type_str = match[2].strip
+        type_and_default = match[2].strip
 
-        if type_str.empty?
+        if type_and_default.empty?
           @errors << "Line #{line_idx + 1}: Expected type after colon for parameter '#{param_name}'"
           next
         end
 
+        # Extract just the type part (before any '=' for default value)
+        type_str = extract_type_from_param(type_and_default)
+        next if type_str.nil? || type_str.empty?
+
         validate_type_expression(type_str, line_idx, "parameter type for '#{param_name}'")
       end
     end
 
+    # Extract type from "Type = default_value" or just "Type"
+    def extract_type_from_param(type_and_default)
+      # Find the position of '=' that's not inside parentheses/brackets
+      depth = 0
+      type_and_default.each_char.with_index do |char, i|
+        case char
+        when "(", "<", "["
+          depth += 1
+        when ")", ">", "]"
+          depth -= 1
+        when "="
+          # Make sure it's not part of -> operator
+          prev_char = i.positive? ? type_and_default[i - 1] : nil
+          next if %w[- ! = < >].include?(prev_char)
+
+          return type_and_default[0...i].strip if depth.zero?
+        end
+      end
+      type_and_default
+    end
+
     def split_parameters(params_str)
       result = []
       current = ""
-      depth = 0
+      paren_depth = 0
+      bracket_depth = 0
+      angle_depth = 0
+      brace_depth = 0
+
+      i = 0
+      while i < params_str.length
+        char = params_str[i]
+        next_char = params_str[i + 1]
+        prev_char = i.positive? ? params_str[i - 1] : nil
 
-      params_str.each_char do |char|
         case char
-        when "<", "[", "("
-          depth += 1
+        when "("
+          paren_depth += 1
           current += char
-        when ">", "]", ")"
-          depth -= 1
+        when ")"
+          paren_depth -= 1
+          current += char
+        when "["
+          bracket_depth += 1
+          current += char
+        when "]"
+          bracket_depth -= 1
+          current += char
+        when "<"
+          # Only count as generic if it's not part of operator like <=, <=>
+          if next_char != "=" && next_char != ">"
+            angle_depth += 1
+          end
+          current += char
+        when ">"
+          # Only count as closing generic if we're inside a generic (angle_depth > 0)
+          # and it's not part of -> operator
+          if angle_depth.positive? && prev_char != "-"
+            angle_depth -= 1
+          end
+          current += char
+        when "{"
+          brace_depth += 1
+          current += char
+        when "}"
+          brace_depth -= 1
           current += char
         when ","
-          if depth.zero?
+          if paren_depth.zero? && bracket_depth.zero? && angle_depth.zero? && brace_depth.zero?
             result << current.strip
             current = ""
           else
@@ -245,6 +364,7 @@ module TRuby
         else
           current += char
         end
+        i += 1
       end
 
       result << current.strip unless current.empty?
@@ -263,7 +383,7 @@ module TRuby
         return_type = match[2]&.strip
 
         # Check return type if it's a simple type name
-        if return_type&.match?(/^\w+$/) && !(VALID_TYPES.include?(return_type) || @type_aliases.key?(return_type))
+        if return_type&.match?(/^\w+$/) && !(VALID_TYPES.include?(return_type) || @type_aliases.key?(return_type) || @interfaces.key?(return_type))
           @errors << "Line #{idx + 1}: Unknown return type '#{return_type}'"
         end
 
@@ -286,24 +406,70 @@ module TRuby
 
         # Only check simple type names against VALID_TYPES
         next unless param_type.match?(/^\w+$/)
-        next if VALID_TYPES.include?(param_type) || @type_aliases.key?(param_type)
+        next if VALID_TYPES.include?(param_type) || @type_aliases.key?(param_type) || @interfaces.key?(param_type)
 
         @errors << "Line #{line_idx + 1}: Unknown parameter type '#{param_type}'"
       end
     end
 
     def check_duplicate_definitions
+      current_class = nil
+      class_methods = {} # { class_name => { method_name => line_number } }
+
       @lines.each_with_index do |line, idx|
-        next unless line.match?(/^\s*def\s+(\w+)/)
+        # Track class context
+        if line.match?(/^\s*class\s+(\w+)/)
+          current_class = line.match(/class\s+(\w+)/)[1]
+          class_methods[current_class] ||= {}
+        elsif line.match?(/^\s*end\s*$/) && current_class
+          # Simple heuristic: top-level 'end' closes current class
+          # This is imperfect but handles most cases
+          current_class = nil if line.match?(/^end\s*$/)
+        end
+
+        # Use unicode-aware pattern for function names (supports Korean, etc.)
+        next unless line.match?(/^\s*def\s+#{IDENTIFIER_PATTERN}/)
 
-        func_name = line.match(/def\s+(\w+)/)[1]
+        func_name = line.match(/def\s+(#{IDENTIFIER_PATTERN})/)[1]
 
-        if @functions[func_name]
+        if current_class
+          # Method inside a class - check within class scope
+          methods = class_methods[current_class]
+          if methods[func_name]
+            @errors << "Line #{idx + 1}: Function '#{func_name}' is already defined at line #{methods[func_name]}"
+          else
+            methods[func_name] = idx + 1
+          end
+        elsif @functions[func_name]
+          # Top-level function - check global scope
           @errors << "Line #{idx + 1}: Function '#{func_name}' is already defined at line #{@functions[func_name]}"
         else
           @functions[func_name] = idx + 1
         end
       end
     end
+
+    # Count angle brackets excluding those in -> arrow operators
+    # Returns the balance (positive if more <, negative if more >)
+    def count_angle_brackets(type_str)
+      balance = 0
+      i = 0
+      while i < type_str.length
+        char = type_str[i]
+        prev_char = i.positive? ? type_str[i - 1] : nil
+        next_char = type_str[i + 1]
+
+        case char
+        when "<"
+          # Skip if it's part of <= or <>
+          balance += 1 unless %w[= >].include?(next_char)
+        when ">"
+          # Skip if it's part of -> arrow operator
+          balance -= 1 unless prev_char == "-"
+        end
+        i += 1
+      end
+      balance
+    end
   end
 end

data/lib/t_ruby/error_reporter.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module TRuby
+  class ErrorReporter
+    attr_reader :diagnostics
+
+    def initialize(formatter: nil)
+      @diagnostics = []
+      @formatter = formatter || DiagnosticFormatter.new
+      @source_cache = {}
+    end
+
+    def add(diagnostic)
+      @diagnostics << diagnostic
+    end
+
+    def add_type_check_error(error, file:, source: nil)
+      source ||= load_source(file)
+      add(Diagnostic.from_type_check_error(error, file: file, source: source))
+    end
+
+    def add_parse_error(error, file:, source: nil)
+      source ||= load_source(file)
+      add(Diagnostic.from_parse_error(error, file: file, source: source))
+    end
+
+    def add_scan_error(error, file:, source: nil)
+      source ||= load_source(file)
+      add(Diagnostic.from_scan_error(error, file: file, source: source))
+    end
+
+    def has_errors?
+      @diagnostics.any? { |d| d.severity == Diagnostic::SEVERITY_ERROR }
+    end
+
+    def error_count
+      @diagnostics.count { |d| d.severity == Diagnostic::SEVERITY_ERROR }
+    end
+
+    def report
+      @formatter.format_all(@diagnostics)
+    end
+
+    def clear
+      @diagnostics.clear
+      @source_cache.clear
+    end
+
+    private
+
+    def load_source(file)
+      return nil unless file && File.exist?(file)
+
+      @source_cache[file] ||= File.read(file)
+    end
+  end
+end

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
@@ -658,6 +672,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 +812,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
 

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)