t-ruby 0.0.41 → 0.0.43

data/lib/t_ruby/diagnostic.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module TRuby
+  class Diagnostic
+    SEVERITY_ERROR = :error
+    SEVERITY_WARNING = :warning
+    SEVERITY_INFO = :info
+    SEVERITY_HINT = :hint
+
+    attr_reader :code, :message, :file, :line, :column, :end_column,
+                :severity, :expected, :actual, :suggestion, :source_line
+
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(
+      code:,
+      message:,
+      file: nil,
+      line: nil,
+      column: nil,
+      end_column: nil,
+      severity: SEVERITY_ERROR,
+      expected: nil,
+      actual: nil,
+      suggestion: nil,
+      source_line: nil
+    )
+      # rubocop:enable Metrics/ParameterLists
+      @code = code
+      @message = message
+      @file = file
+      @line = line
+      @column = column || 1
+      @end_column = end_column || (@column + 1)
+      @severity = severity
+      @expected = expected
+      @actual = actual
+      @suggestion = suggestion
+      @source_line = source_line
+    end
+
+    def self.from_type_check_error(error, file: nil, source: nil)
+      line, col = parse_location(error.location)
+      source_line = extract_source_line(source, line) if source && line
+
+      new(
+        code: "TR2001",
+        message: error.error_message,
+        file: file,
+        line: line,
+        column: col,
+        severity: error.severity || SEVERITY_ERROR,
+        expected: error.expected,
+        actual: error.actual,
+        suggestion: error.suggestion,
+        source_line: source_line
+      )
+    end
+
+    def self.from_parse_error(error, file: nil, source: nil)
+      source_line = extract_source_line(source, error.line) if source && error.line
+
+      new(
+        code: "TR1001",
+        message: error.message,
+        file: file,
+        line: error.line,
+        column: error.column,
+        source_line: source_line
+      )
+    end
+
+    def self.from_scan_error(error, file: nil, source: nil)
+      source_line = extract_source_line(source, error.line) if source && error.line
+      # ScanError adds " at line X, column Y" to the message in its constructor
+      message = error.message.sub(/ at line \d+, column \d+\z/, "")
+
+      new(
+        code: "TR1001",
+        message: message,
+        file: file,
+        line: error.line,
+        column: error.column,
+        source_line: source_line
+      )
+    end
+
+    def error?
+      @severity == SEVERITY_ERROR
+    end
+
+    def self.parse_location(location_str)
+      return [nil, 1] unless location_str
+
+      case location_str
+      when /:(\d+):(\d+)$/
+        [::Regexp.last_match(1).to_i, ::Regexp.last_match(2).to_i]
+      when /:(\d+)$/
+        [::Regexp.last_match(1).to_i, 1]
+      when /line (\d+)/i
+        [::Regexp.last_match(1).to_i, 1]
+      else
+        [nil, 1]
+      end
+    end
+
+    def self.extract_source_line(source, line_num)
+      return nil unless source && line_num
+
+      lines = source.split("\n")
+      lines[line_num - 1] if line_num.positive? && line_num <= lines.length
+    end
+
+    private_class_method :parse_location, :extract_source_line
+  end
+end

data/lib/t_ruby/diagnostic_formatter.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module TRuby
+  class DiagnosticFormatter
+    COLORS = {
+      reset: "\e[0m",
+      bold: "\e[1m",
+      dim: "\e[2m",
+      red: "\e[31m",
+      green: "\e[32m",
+      yellow: "\e[33m",
+      blue: "\e[34m",
+      cyan: "\e[36m",
+      gray: "\e[90m",
+      white: "\e[37m",
+    }.freeze
+
+    def initialize(use_colors: nil)
+      @use_colors = use_colors.nil? ? $stdout.tty? : use_colors
+    end
+
+    def format(diagnostic)
+      lines = []
+
+      lines << format_header(diagnostic)
+
+      if diagnostic.source_line && diagnostic.line
+        lines << ""
+        lines << format_source_snippet(diagnostic)
+        lines << format_marker(diagnostic)
+        lines.concat(format_context(diagnostic))
+      end
+
+      lines.join("\n")
+    end
+
+    def format_all(diagnostics)
+      return "" if diagnostics.empty?
+
+      output = diagnostics.map { |d| format(d) }.join("\n\n")
+      "#{output}\n\n#{format_summary(diagnostics)}"
+    end
+
+    private
+
+    def format_header(diagnostic)
+      location = format_location(diagnostic)
+      severity_text = colorize(severity_color(diagnostic.severity), diagnostic.severity.to_s)
+      code_text = colorize(:gray, diagnostic.code)
+
+      "#{location} - #{severity_text} #{code_text}: #{diagnostic.message}"
+    end
+
+    def format_location(diagnostic)
+      file_part = colorize(:cyan, diagnostic.file || "<unknown>")
+
+      if diagnostic.line
+        line_part = colorize(:yellow, diagnostic.line.to_s)
+        col_part = colorize(:yellow, diagnostic.column.to_s)
+        "#{file_part}:#{line_part}:#{col_part}"
+      else
+        file_part
+      end
+    end
+
+    def format_source_snippet(diagnostic)
+      line_num = diagnostic.line.to_s.rjust(4)
+      line_num_colored = colorize(:gray, line_num)
+
+      "#{line_num_colored} | #{diagnostic.source_line}"
+    end
+
+    def format_marker(diagnostic)
+      col = diagnostic.column || 1
+      width = calculate_marker_width(diagnostic)
+
+      indent = "#{" " * 4} | #{" " * (col - 1)}"
+      marker = colorize(:red, "~" * width)
+
+      "#{indent}#{marker}"
+    end
+
+    def calculate_marker_width(diagnostic)
+      # If end_column is explicitly set (not just default column + 1), use it
+      if diagnostic.end_column && diagnostic.end_column > diagnostic.column + 1
+        diagnostic.end_column - diagnostic.column
+      elsif diagnostic.source_line
+        # Try to guess width from identifier at error position
+        remaining = diagnostic.source_line[(diagnostic.column - 1)..]
+        if remaining && remaining =~ /^(\w+)/
+          ::Regexp.last_match(1).length
+        else
+          1
+        end
+      else
+        1
+      end
+    end
+
+    def format_context(diagnostic)
+      lines = []
+      indent = "#{" " * 4} | "
+
+      if diagnostic.expected
+        label = colorize(:dim, "Expected:")
+        value = colorize(:green, diagnostic.expected)
+        lines << "#{indent}#{label} #{value}"
+      end
+
+      if diagnostic.actual
+        label = colorize(:dim, "Actual:")
+        value = colorize(:red, diagnostic.actual)
+        lines << "#{indent}#{label} #{value}"
+      end
+
+      if diagnostic.suggestion
+        label = colorize(:dim, "Suggestion:")
+        lines << "#{indent}#{label} #{diagnostic.suggestion}"
+      end
+
+      lines
+    end
+
+    def format_summary(diagnostics)
+      error_count = diagnostics.count { |d| d.severity == Diagnostic::SEVERITY_ERROR }
+      warning_count = diagnostics.count { |d| d.severity == Diagnostic::SEVERITY_WARNING }
+
+      parts = []
+
+      if error_count.positive?
+        error_word = error_count == 1 ? "error" : "errors"
+        parts << colorize(:red, "#{error_count} #{error_word}")
+      end
+
+      if warning_count.positive?
+        warning_word = warning_count == 1 ? "warning" : "warnings"
+        parts << colorize(:yellow, "#{warning_count} #{warning_word}")
+      end
+
+      if parts.empty?
+        colorize(:green, "No errors found.")
+      else
+        "Found #{parts.join(" and ")}."
+      end
+    end
+
+    def severity_color(severity)
+      case severity
+      when :error then :red
+      when :warning then :yellow
+      else :white
+      end
+    end
+
+    def colorize(color, text)
+      return text.to_s unless @use_colors
+      return text.to_s unless COLORS[color]
+
+      "#{COLORS[color]}#{text}#{COLORS[:reset]}"
+    end
+  end
+end

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