t-ruby 0.0.42 → 0.0.43

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75019794a577853cf5a7e704febef3868a1ddd06776e43f50dc684d7dde87e3c
-  data.tar.gz: 89a255f7e7b68e2becd6314be09470424d5f418324c40bcc77a7311e6006d9f0
+  metadata.gz: cb406ad473738afc16343a01b9f7e8e0f77a8b0fe700dd3ced2df65197bce626
+  data.tar.gz: 95f1ce4ede5378e17393046c223c46b404d95e6506235e210aeba20a9615f8ac
 SHA512:
-  metadata.gz: 4000a38df6e83591a15f453af3b4d5f759b1af8e869478737c1d7711e34c7e1d65c89df34e56a6575d41e2f120e951970fde1ac444bf24d73c1167a24de875c4
-  data.tar.gz: 9273b4bf7d8a9af3ccbe0fa0d93914b13c9ce09f464902a4974749780871516c8fbaeb33a60d1dca754914dde09e498148ec080ff31fef3b11a0a88d96642eee
+  metadata.gz: 6003aa038a7b476b8682aed9e32ba19ddbee6c124fe294c79b0371924527002f20c3ccdf45f71e2ee7360bef4e126d1ee0c15d93afd033df1166c20b5719187a
+  data.tar.gz: c0c462fada5b5d98f46298dc307d6000b56d537b8d7f80af1faba2206c682cebf02e588277ca5ea2bf6f4e21141928540c733f0f8851adc48b4ca1be8ede6f81

data/lib/t_ruby/ast_type_inferrer.rb

@@ -158,6 +158,8 @@ module TRuby
       type = case node
              when IR::Literal
                infer_literal(node)
+             when IR::InterpolatedString
+               "String" # Interpolated strings always produce String
              when IR::VariableRef
                infer_variable_ref(node, env)
              when IR::BinaryOp

data/lib/t_ruby/cache.rb

@@ -318,7 +318,7 @@ module TRuby
     def needs_compile?(file_path)
       return true unless File.exist?(file_path)
 
-      current_hash = file_hash(file_path)
+      current_hash = compute_file_hash(file_path)
       stored_hash = @file_hashes[file_path]
 
       return true if stored_hash.nil? || stored_hash != current_hash
@@ -333,7 +333,7 @@ module TRuby
       return @compiled_files[file_path] unless needs_compile?(file_path)
 
       result = @compiler.compile(file_path)
-      @file_hashes[file_path] = file_hash(file_path)
+      @file_hashes[file_path] = compute_file_hash(file_path)
       @compiled_files[file_path] = result
 
       result
@@ -365,9 +365,14 @@ module TRuby
       @cache.stats # Just accessing for potential cleanup
     end
 
+    # Update file hash after external compile (for watcher integration)
+    def update_file_hash(file_path)
+      @file_hashes[file_path] = compute_file_hash(file_path)
+    end
+
     private
 
-    def file_hash(file_path)
+    def compute_file_hash(file_path)
       return nil unless File.exist?(file_path)
 
       Digest::SHA256.hexdigest(File.read(file_path))
@@ -683,27 +688,52 @@ module TRuby
     end
 
     # Compile all with cross-file checking
+    # Returns diagnostics using unified Diagnostic format
     def compile_all_with_checking(file_paths)
       results = {}
-      errors = []
+      all_diagnostics = []
 
       # First pass: compile and register all files
       file_paths.each do |file_path|
-        results[file_path] = compile_with_ir(file_path)
-      rescue StandardError => e
-        errors << { file: file_path, error: e.message }
+        source = File.exist?(file_path) ? File.read(file_path) : nil
+
+        begin
+          results[file_path] = compile_with_ir(file_path)
+        rescue TypeCheckError => e
+          all_diagnostics << Diagnostic.from_type_check_error(e, file: file_path, source: source)
+        rescue ParseError => e
+          all_diagnostics << Diagnostic.from_parse_error(e, file: file_path, source: source)
+        rescue Scanner::ScanError => e
+          all_diagnostics << Diagnostic.from_scan_error(e, file: file_path, source: source)
+        rescue StandardError => e
+          all_diagnostics << Diagnostic.new(
+            code: "TR0001",
+            message: e.message,
+            file: file_path,
+            line: 1,
+            column: 1
+          )
+        end
       end
 
       # Second pass: cross-file type checking
       if @cross_file_checker
         check_result = @cross_file_checker.check_all
-        errors.concat(check_result[:errors])
+        check_result[:errors].each do |e|
+          all_diagnostics << Diagnostic.new(
+            code: "TR2002",
+            message: e[:message],
+            file: e[:file],
+            line: 1,
+            column: 1
+          )
+        end
       end
 
       {
         results: results,
-        errors: errors,
-        success: errors.empty?,
+        diagnostics: all_diagnostics,
+        success: all_diagnostics.empty?,
       }
     end
 

data/lib/t_ruby/cli.rb

@@ -214,14 +214,19 @@ module TRuby
       config = Config.new(config_path)
       compiler = Compiler.new(config)
 
-      output_path = compiler.compile(input_file)
-      puts "Compiled: #{input_file} -> #{output_path}"
-    rescue TypeCheckError => e
-      puts "Type error: #{e.message}"
-      exit 1
-    rescue ArgumentError => e
-      puts "Error: #{e.message}"
-      exit 1
+      result = compiler.compile_with_diagnostics(input_file)
+
+      if result[:success]
+        puts "Compiled: #{input_file} -> #{result[:output_path]}"
+      else
+        formatter = DiagnosticFormatter.new(use_colors: $stdout.tty?)
+        result[:diagnostics].each do |diagnostic|
+          puts formatter.format(diagnostic)
+        end
+        puts
+        puts formatter.send(:format_summary, result[:diagnostics])
+        exit 1
+      end
     end
 
     # Extract config path from --config or -c flag

data/lib/t_ruby/compiler.rb

@@ -76,6 +76,161 @@ module TRuby
       output_path
     end
 
+    # Compile a file and return result with diagnostics
+    # This is the unified compilation interface for CLI and Watcher
+    # @param input_path [String] Path to the input file
+    # @return [Hash] Result with :success, :output_path, :diagnostics keys
+    def compile_with_diagnostics(input_path)
+      source = File.exist?(input_path) ? File.read(input_path) : nil
+      all_diagnostics = []
+
+      # Run analyze first to get all diagnostics (colon spacing, etc.)
+      if source
+        all_diagnostics = analyze(source, file: input_path)
+      end
+
+      begin
+        output_path = compile(input_path)
+        # Compilation succeeded, but we may still have diagnostics from analyze
+        {
+          success: all_diagnostics.empty?,
+          output_path: all_diagnostics.empty? ? output_path : nil,
+          diagnostics: all_diagnostics,
+        }
+      rescue TypeCheckError => e
+        # Skip if already reported by analyze (same message and location)
+        new_diag = Diagnostic.from_type_check_error(e, file: input_path, source: source)
+        unless all_diagnostics.any? { |d| d.message == new_diag.message && d.line == new_diag.line }
+          all_diagnostics << new_diag
+        end
+        {
+          success: false,
+          output_path: nil,
+          diagnostics: all_diagnostics,
+        }
+      rescue ParseError => e
+        new_diag = Diagnostic.from_parse_error(e, file: input_path, source: source)
+        unless all_diagnostics.any? { |d| d.message == new_diag.message && d.line == new_diag.line }
+          all_diagnostics << new_diag
+        end
+        {
+          success: false,
+          output_path: nil,
+          diagnostics: all_diagnostics,
+        }
+      rescue Scanner::ScanError => e
+        new_diag = Diagnostic.from_scan_error(e, file: input_path, source: source)
+        unless all_diagnostics.any? { |d| d.message == new_diag.message && d.line == new_diag.line }
+          all_diagnostics << new_diag
+        end
+        {
+          success: false,
+          output_path: nil,
+          diagnostics: all_diagnostics,
+        }
+      rescue ArgumentError => e
+        all_diagnostics << Diagnostic.new(
+          code: "TR0001",
+          message: e.message,
+          file: input_path,
+          severity: Diagnostic::SEVERITY_ERROR
+        )
+        {
+          success: false,
+          output_path: nil,
+          diagnostics: all_diagnostics,
+        }
+      end
+    end
+
+    # Analyze source code without compiling - returns diagnostics only
+    # This is the unified analysis interface for LSP and other tools
+    # @param source [String] T-Ruby source code
+    # @param file [String] File path for error reporting (optional)
+    # @return [Array<Diagnostic>] Array of diagnostic objects
+    def analyze(source, file: "<source>")
+      diagnostics = []
+      source_lines = source.split("\n")
+
+      # Run ErrorHandler checks (syntax validation, duplicate definitions, etc.)
+      error_handler = ErrorHandler.new(source)
+      errors = error_handler.check
+      errors.each do |error|
+        # Parse line number from "Line N: message" format
+        next unless error =~ /^Line (\d+):\s*(.+)$/
+
+        line_num = Regexp.last_match(1).to_i
+        message = Regexp.last_match(2)
+        source_line = source_lines[line_num - 1] if line_num.positive?
+        diagnostics << Diagnostic.new(
+          code: "TR1002",
+          message: message,
+          file: file,
+          line: line_num,
+          column: 1,
+          source_line: source_line,
+          severity: Diagnostic::SEVERITY_ERROR
+        )
+      end
+
+      # Run TokenDeclarationParser for colon spacing and declaration syntax validation
+      begin
+        scanner = Scanner.new(source)
+        tokens = scanner.scan_all
+        decl_parser = ParserCombinator::TokenDeclarationParser.new
+        decl_parser.parse_program(tokens)
+
+        if decl_parser.has_errors?
+          decl_parser.errors.each do |err|
+            source_line = source_lines[err.line - 1] if err.line.positive? && err.line <= source_lines.length
+            diagnostics << Diagnostic.new(
+              code: "TR1003",
+              message: err.message,
+              file: file,
+              line: err.line,
+              column: err.column,
+              source_line: source_line,
+              severity: Diagnostic::SEVERITY_ERROR
+            )
+          end
+        end
+      rescue Scanner::ScanError
+        # Scanner errors will be caught below in the main parse section
+      rescue StandardError
+        # Ignore TokenDeclarationParser errors for now - regex parser is authoritative
+      end
+
+      begin
+        # Parse source with regex-based parser for IR generation
+        parser = Parser.new(source)
+        parser.parse
+
+        # Run type checking if enabled and IR is available
+        if type_check? && parser.ir_program
+          begin
+            check_types(parser.ir_program, file)
+          rescue TypeCheckError => e
+            diagnostics << Diagnostic.from_type_check_error(e, file: file, source: source)
+          end
+        end
+      rescue ParseError => e
+        diagnostics << Diagnostic.from_parse_error(e, file: file, source: source)
+      rescue Scanner::ScanError => e
+        diagnostics << Diagnostic.from_scan_error(e, file: file, source: source)
+      rescue StandardError => e
+        diagnostics << Diagnostic.new(
+          code: "TR0001",
+          message: e.message,
+          file: file,
+          line: 1,
+          column: 1,
+          severity: Diagnostic::SEVERITY_ERROR
+        )
+      end
+
+      diagnostics
+    end
+
     # Compile T-Ruby source code from a string (useful for WASM/playground)
     # @param source [String] T-Ruby source code
     # @param options [Hash] Options for compilation
@@ -319,6 +474,19 @@ module TRuby
       # Subtype relationships
       return true if subtype_of?(inferred, declared)
 
+      # Handle generic types (e.g., Array[untyped] is compatible with Array[String])
+      if inferred.include?("[") && declared.include?("[")
+        inferred_base = inferred.split("[").first
+        declared_base = declared.split("[").first
+        if inferred_base == declared_base
+          # Extract type arguments
+          inferred_args = inferred[/\[(.+)\]/, 1]
+          declared_args = declared[/\[(.+)\]/, 1]
+          # untyped type argument is compatible with any type argument
+          return true if inferred_args == "untyped" || declared_args == "untyped"
+        end
+      end
+
       # Handle union types in declared
       if declared.include?("|")
         declared_types = declared.split("|").map(&:strip)

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