t-ruby 0.0.35 → 0.0.36

data/lib/t_ruby/smt_solver.rb

@@ -442,6 +442,7 @@ module TRuby
 
       def simplify
         return TRUE if @left == @right
+
         self
       end
 
@@ -634,17 +635,17 @@ module TRuby
 
       # Type hierarchy (built-in)
       TYPE_HIERARCHY = {
-        "Integer" => ["Numeric", "Object"],
-        "Float" => ["Numeric", "Object"],
+        "Integer" => %w[Numeric Object],
+        "Float" => %w[Numeric Object],
         "Numeric" => ["Object"],
         "String" => ["Object"],
-        "Array" => ["Enumerable", "Object"],
-        "Hash" => ["Enumerable", "Object"],
+        "Array" => %w[Enumerable Object],
+        "Hash" => %w[Enumerable Object],
         "Enumerable" => ["Object"],
         "Boolean" => ["Object"],
         "Symbol" => ["Object"],
         "nil" => ["Object"],
-        "Object" => []
+        "Object" => [],
       }.freeze
 
       def initialize
@@ -694,7 +695,7 @@ module TRuby
         {
           success: @errors.empty?,
           solution: @solution,
-          errors: @errors
+          errors: @errors,
         }
       end
 
@@ -748,18 +749,21 @@ module TRuby
         # If left is type variable, bind it
         if left.is_a?(TypeVar)
           return nil if occurs_check(left, right)
+
           return { left.name => right }
         end
 
         # If right is type variable, bind it
         if right.is_a?(TypeVar)
           return nil if occurs_check(right, left)
+
           return { right.name => left }
         end
 
         # Both are concrete types
         if left.is_a?(ConcreteType) && right.is_a?(ConcreteType)
           return {} if left.name == right.name
+
           return nil
         end
 
@@ -768,6 +772,7 @@ module TRuby
 
       def occurs_check(var, type)
         return false unless type.respond_to?(:free_variables)
+
         type.free_variables.include?(var.name)
       end
 
@@ -800,7 +805,7 @@ module TRuby
       end
 
       def instantiate_remaining
-        @type_vars.each do |name, var|
+        @type_vars.each_key do |name|
           next if @solution[name]
 
           # Default to Object if no constraints
@@ -824,24 +829,23 @@ module TRuby
       # Infer types for a method
       def infer_method(method_ir)
         param_types = {}
-        return_type = nil
 
         # Create type variables for parameters without annotations
         method_ir.params.each do |param|
-          if param.type_annotation
-            param_types[param.name] = type_from_ir(param.type_annotation)
-          else
-            param_types[param.name] = @solver.fresh_var("P_#{param.name}")
-          end
+          param_types[param.name] = if param.type_annotation
+                                      type_from_ir(param.type_annotation)
+                                    else
+                                      @solver.fresh_var("P_#{param.name}")
+                                    end
           @type_env[param.name] = param_types[param.name]
         end
 
         # Create type variable for return type if not annotated
         return_type = if method_ir.return_type
-          type_from_ir(method_ir.return_type)
-        else
-          @solver.fresh_var("R_#{method_ir.name}")
-        end
+                        type_from_ir(method_ir.return_type)
+                      else
+                        @solver.fresh_var("R_#{method_ir.name}")
+                      end
 
         # Analyze body to generate constraints
         if method_ir.body
@@ -862,12 +866,12 @@ module TRuby
           {
             success: true,
             params: inferred_params,
-            return_type: inferred_return
+            return_type: inferred_return,
           }
         else
           {
             success: false,
-            errors: result[:errors]
+            errors: result[:errors],
           }
         end
       end
@@ -977,17 +981,17 @@ module TRuby
       def infer_method_call(call)
         # Get receiver type
         receiver_type = if call.receiver
-          infer_expression(call.receiver)
-        else
-          @type_env["self"] || ConcreteType.new("Object")
-        end
+                          infer_expression(call.receiver)
+                        else
+                          @type_env["self"] || ConcreteType.new("Object")
+                        end
 
         # Look up method return type
         return_type = lookup_method_type(receiver_type, call.method_name)
         return_type || @solver.fresh_var("M_#{call.method_name}")
       end
 
-      def lookup_method_type(receiver, method)
+      def lookup_method_type(_receiver, method)
         # Built-in method types
         method_types = {
           "to_s" => ConcreteType.new("String"),
@@ -996,7 +1000,7 @@ module TRuby
           "length" => ConcreteType.new("Integer"),
           "size" => ConcreteType.new("Integer"),
           "empty?" => ConcreteType.new("Boolean"),
-          "nil?" => ConcreteType.new("Boolean")
+          "nil?" => ConcreteType.new("Boolean"),
         }
 
         method_types[method.to_s]
@@ -1022,16 +1026,14 @@ module TRuby
       end
 
       def infer_array_literal(expr)
-        if expr.elements.empty?
-          ConcreteType.new("Array")
-        else
+        unless expr.elements.empty?
           element_type = @solver.fresh_var("E")
           expr.elements.each do |elem|
             elem_type = infer_expression(elem)
             @solver.add_subtype(elem_type, element_type)
           end
-          ConcreteType.new("Array")
         end
+        ConcreteType.new("Array")
       end
     end
 

data/lib/t_ruby/type_alias_registry.rb

@@ -45,6 +45,7 @@ module TRuby
 
     def valid_type?(name)
       return true if BUILT_IN_TYPES.include?(name)
+
       @aliases.key?(name)
     end
 

data/lib/t_ruby/type_checker.rb

@@ -30,7 +30,7 @@ module TRuby
         location: @location,
         expected: @expected,
         actual: @actual,
-        suggestion: @suggestion
+        suggestion: @suggestion,
       }
     end
   end
@@ -42,17 +42,17 @@ module TRuby
 
     def initialize
       @subtypes = {
-        "Integer" => ["Numeric", "Object"],
-        "Float" => ["Numeric", "Object"],
+        "Integer" => %w[Numeric Object],
+        "Float" => %w[Numeric Object],
         "Numeric" => ["Object"],
         "String" => ["Object"],
         "Symbol" => ["Object"],
-        "Array" => ["Enumerable", "Object"],
-        "Hash" => ["Enumerable", "Object"],
-        "Set" => ["Enumerable", "Object"],
+        "Array" => %w[Enumerable Object],
+        "Hash" => %w[Enumerable Object],
+        "Set" => %w[Enumerable Object],
         "Boolean" => ["Object"],
         "nil" => ["Object"],
-        "Object" => []
+        "Object" => [],
       }
     end
 
@@ -206,7 +206,7 @@ module TRuby
       {
         success: @errors.empty?,
         errors: @errors,
-        warnings: @warnings
+        warnings: @warnings,
       }
     end
 
@@ -220,10 +220,10 @@ module TRuby
           params: method_ir.params.map do |p|
             {
               name: p.name,
-              type: result[:params][p.name] || infer_param_type(p)
+              type: result[:params][p.name] || infer_param_type(p),
             }
           end,
-          return_type: result[:return_type]
+          return_type: result[:return_type],
         }
       else
         # Add errors from SMT solver
@@ -305,7 +305,7 @@ module TRuby
     def register_function(name, params:, return_type:)
       @function_signatures[name] = {
         params: params,
-        return_type: return_type
+        return_type: return_type,
       }
     end
 
@@ -345,15 +345,15 @@ module TRuby
 
         next unless arg_type
 
-        unless type_compatible?(arg_type, param[:type])
-          add_error(
-            message: "Type mismatch in argument '#{param[:name]}' of #{function_name}",
-            expected: param[:type],
-            actual: arg_type,
-            suggestion: suggest_conversion(arg_type, param[:type]),
-            location: location
-          )
-        end
+        next if type_compatible?(arg_type, param[:type])
+
+        add_error(
+          message: "Type mismatch in argument '#{param[:name]}' of #{function_name}",
+          expected: param[:type],
+          actual: arg_type,
+          suggestion: suggest_conversion(arg_type, param[:type]),
+          location: location
+        )
       end
 
       signature[:return_type]
@@ -384,16 +384,14 @@ module TRuby
     def check_assignment(variable, value, declared_type: nil, location: nil)
       value_type = infer_type(value)
 
-      if declared_type
-        unless type_compatible?(value_type, declared_type)
-          add_error(
-            message: "Cannot assign #{value_type} to variable of type #{declared_type}",
-            expected: declared_type,
-            actual: value_type,
-            location: location
-          )
-          return false
-        end
+      if declared_type && !type_compatible?(value_type, declared_type)
+        add_error(
+          message: "Cannot assign #{value_type} to variable of type #{declared_type}",
+          expected: declared_type,
+          actual: value_type,
+          location: location
+        )
+        return false
       end
 
       @current_scope.define(variable, declared_type || value_type)
@@ -408,7 +406,7 @@ module TRuby
         "Array" => %w[length size first last empty? count],
         "Hash" => %w[keys values size empty? length],
         "Integer" => %w[abs to_s to_f even? odd? positive? negative?],
-        "Float" => %w[abs to_s to_i ceil floor round]
+        "Float" => %w[abs to_s to_i ceil floor round],
       }
 
       properties = known_properties[receiver_type]
@@ -451,6 +449,7 @@ module TRuby
 
         # Result type depends on operands
         return "Float" if left_type == "Float" || right_type == "Float"
+
         return "Integer"
       end
 
@@ -490,14 +489,14 @@ module TRuby
         else_scope&.narrow(var, remove_nil_from_type(@current_scope.lookup(var) || "Object"))
       end
 
-      if condition.match?(/!(\w+)\.nil\?/)
-        match = condition.match(/!(\w+)\.nil\?/)
-        var = match[1]
+      return unless condition.match?(/!(\w+)\.nil\?/)
 
-        # Variable is not nil in then branch
-        then_scope.narrow(var, remove_nil_from_type(@current_scope.lookup(var) || "Object"))
-        else_scope&.narrow(var, "nil")
-      end
+      match = condition.match(/!(\w+)\.nil\?/)
+      var = match[1]
+
+      # Variable is not nil in then branch
+      then_scope.narrow(var, remove_nil_from_type(@current_scope.lookup(var) || "Object"))
+      else_scope&.narrow(var, "nil")
     end
 
     # Check a complete function
@@ -528,7 +527,7 @@ module TRuby
 
       # Return statement
       if line.match?(/^return\s+(.+)/)
-        match = line.match(/^return\s+(.+)/)
+        line.match(/^return\s+(.+)/)
         # Would need current function context for proper checking
         return
       end
@@ -573,8 +572,10 @@ module TRuby
 
     # Check if a type name is known
     def known_type?(type_name)
-      return true if %w[String Integer Float Boolean Array Hash Symbol void nil Object Numeric Enumerable].include?(type_name)
+      return true if %w[String Integer Float Boolean Array Hash Symbol void nil Object Numeric
+                        Enumerable].include?(type_name)
       return true if @type_aliases.key?(type_name)
+
       false
     end
 
@@ -611,7 +612,7 @@ module TRuby
       {
         success: @errors.empty?,
         errors: @errors,
-        warnings: @warnings
+        warnings: @warnings,
       }
     end
 
@@ -685,14 +686,14 @@ module TRuby
 
     def suggest_conversion(from_type, to_type)
       conversions = {
-        ["Integer", "String"] => "Use .to_s to convert to String",
-        ["Float", "String"] => "Use .to_s to convert to String",
-        ["String", "Integer"] => "Use .to_i to convert to Integer",
-        ["String", "Float"] => "Use .to_f to convert to Float",
-        ["Integer", "Float"] => "Use .to_f to convert to Float",
-        ["Float", "Integer"] => "Use .to_i to convert to Integer (may lose precision)",
-        ["Symbol", "String"] => "Use .to_s to convert to String",
-        ["String", "Symbol"] => "Use .to_sym to convert to Symbol"
+        %w[Integer String] => "Use .to_s to convert to String",
+        %w[Float String] => "Use .to_s to convert to String",
+        %w[String Integer] => "Use .to_i to convert to Integer",
+        %w[String Float] => "Use .to_f to convert to Float",
+        %w[Integer Float] => "Use .to_f to convert to Float",
+        %w[Float Integer] => "Use .to_i to convert to Integer (may lose precision)",
+        %w[Symbol String] => "Use .to_s to convert to String",
+        %w[String Symbol] => "Use .to_sym to convert to Symbol",
       }
 
       conversions[[from_type, to_type]]
@@ -700,22 +701,22 @@ module TRuby
 
     def infer_property_type(receiver_type, property)
       property_types = {
-        ["String", "length"] => "Integer",
-        ["String", "size"] => "Integer",
+        %w[String length] => "Integer",
+        %w[String size] => "Integer",
         ["String", "empty?"] => "Boolean",
-        ["String", "chars"] => "Array<String>",
-        ["Array", "length"] => "Integer",
-        ["Array", "size"] => "Integer",
+        %w[String chars] => "Array<String>",
+        %w[Array length] => "Integer",
+        %w[Array size] => "Integer",
         ["Array", "empty?"] => "Boolean",
-        ["Array", "first"] => nil, # Depends on element type
-        ["Array", "last"] => nil,
-        ["Hash", "keys"] => "Array",
-        ["Hash", "values"] => "Array",
-        ["Hash", "size"] => "Integer",
-        ["Integer", "abs"] => "Integer",
-        ["Integer", "to_s"] => "String",
-        ["Float", "abs"] => "Float",
-        ["Float", "to_i"] => "Integer"
+        %w[Array first] => nil, # Depends on element type
+        %w[Array last] => nil,
+        %w[Hash keys] => "Array",
+        %w[Hash values] => "Array",
+        %w[Hash size] => "Integer",
+        %w[Integer abs] => "Integer",
+        %w[Integer to_s] => "String",
+        %w[Float abs] => "Float",
+        %w[Float to_i] => "Integer",
       }
 
       property_types[[receiver_type, property]]

data/lib/t_ruby/type_erasure.rb

@@ -10,7 +10,7 @@ module TRuby
       result = @source.dup
 
       # Remove type alias definitions: type AliasName = TypeDefinition
-      result = result.gsub(/^\s*type\s+\w+\s*=\s*.+?$\n?/, '')
+      result = result.gsub(/^\s*type\s+\w+\s*=\s*.+?$\n?/, "")
 
       # Remove parameter type annotations: (name: Type) -> (name)
       # Matches: parameter_name: TypeName
@@ -18,9 +18,7 @@ module TRuby
 
       # Remove return type annotations: ): TypeName -> )
       # Matches: ): TypeName or ): TypeName (with spaces/EOF)
-      result = result.gsub(/\)\s*:\s*\w+(\s|$)/, ')\1')
-
-      result
+      result.gsub(/\)\s*:\s*\w+(\s|$)/, ')\1')
     end
   end
 end

data/lib/t_ruby/type_inferencer.rb

@@ -63,7 +63,7 @@ module TRuby
       # Hash literals
       /^\{.*\}$/ => "Hash",
       # Regex literals
-      /^\/.*\/$/ => "Regexp"
+      %r{^/.*/$} => "Regexp",
     }.freeze
 
     # Method return type patterns
@@ -131,7 +131,7 @@ module TRuby
       "equal?" => "Boolean",
       "inspect" => "String",
       "dup" => nil,
-      "clone" => nil
+      "clone" => nil,
     }.freeze
 
     # Operator return types
@@ -161,7 +161,7 @@ module TRuby
       "^" => "Integer",
       "~" => "Integer",
       "<<" => "Integer",
-      ">>" => "Integer"
+      ">>" => "Integer",
     }.freeze
 
     def initialize
@@ -277,15 +277,15 @@ module TRuby
         next unless arg_type
 
         # Extract generic parameter from function param type
-        if param[:type].match?(/^(\w+)<(\w+)>$/)
-          match = param[:type].match(/^(\w+)<(\w+)>$/)
-          generic_name = match[2]
-
-          # If arg type is concrete, bind it
-          if arg_type.type.match?(/^(\w+)<(\w+)>$/)
-            arg_match = arg_type.type.match(/^(\w+)<(\w+)>$/)
-            generic_bindings[generic_name] = arg_match[2]
-          end
+        next unless param[:type].match?(/^(\w+)<(\w+)>$/)
+
+        match = param[:type].match(/^(\w+)<(\w+)>$/)
+        generic_name = match[2]
+
+        # If arg type is concrete, bind it
+        if arg_type.type.match?(/^(\w+)<(\w+)>$/)
+          arg_match = arg_type.type.match(/^(\w+)<(\w+)>$/)
+          generic_bindings[generic_name] = arg_match[2]
         end
       end
 
@@ -425,7 +425,7 @@ module TRuby
         end
 
         # Arithmetic operation
-        if line.match?(/#{param_name}\s*[+\-*\/%]/)
+        if line.match?(%r{#{param_name}\s*[+\-*/%]})
           usages << { type: :arithmetic, line: idx + 1 }
         end
 
@@ -469,15 +469,13 @@ module TRuby
                               .max_by { |_, v| v.length }
                               &.first
 
-      if most_common
-        InferredType.new(
-          type: most_common,
-          confidence: InferredType::MEDIUM,
-          source: :usage_analysis
-        )
-      else
-        nil
-      end
+      return unless most_common
+
+      InferredType.new(
+        type: most_common,
+        confidence: InferredType::MEDIUM,
+        source: :usage_analysis
+      )
     end
 
     def infer_type_from_method(method_name)
@@ -526,7 +524,7 @@ module TRuby
       end
     end
 
-    def infer_operator_result(expr, operator, result_type)
+    def infer_operator_result(_expr, _operator, result_type)
       case result_type
       when "Boolean"
         InferredType.new(type: "Boolean", confidence: InferredType::HIGH, source: :operator)
@@ -541,8 +539,6 @@ module TRuby
       when :propagate
         # Type propagates from operands
         nil
-      else
-        nil
       end
     end
 
@@ -563,7 +559,7 @@ module TRuby
         )
       elsif element_types.length > 1
         InferredType.new(
-          type: "Array<#{element_types.join(' | ')}>",
+          type: "Array<#{element_types.join(" | ")}>",
           confidence: InferredType::MEDIUM,
           source: :literal
         )

data/lib/t_ruby/union_type_parser.rb

@@ -18,20 +18,20 @@ module TRuby
     private
 
     def parse_union
-      members = @type_string.split("|").map { |m| m.strip }.compact
+      members = @type_string.split("|").map(&:strip).compact
 
       {
         type: :union,
         members: members,
         has_duplicates: members.length != members.uniq.length,
-        unique_members: members.uniq
+        unique_members: members.uniq,
       }
     end
 
     def parse_simple
       {
         type: :simple,
-        value: @type_string
+        value: @type_string,
       }
     end
   end

data/lib/t_ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TRuby
-  VERSION = "0.0.35"
+  VERSION = "0.0.36"
 end

data/lib/t_ruby/watcher.rb

@@ -14,7 +14,7 @@ module TRuby
       yellow: "\e[33m",
       blue: "\e[34m",
       cyan: "\e[36m",
-      gray: "\e[90m"
+      gray: "\e[90m",
     }.freeze
 
     attr_reader :incremental_compiler, :stats
@@ -47,7 +47,7 @@ module TRuby
       @stats = {
         total_compilations: 0,
         incremental_hits: 0,
-        total_time: 0.0
+        total_time: 0.0,
       }
     end
 
@@ -92,8 +92,8 @@ module TRuby
 
     def handle_changes(modified, added, removed)
       changed_files = (modified + added)
-        .select { |f| f.end_with?(".trb") || f.end_with?(".rb") }
-        .reject { |f| @config.excluded?(f) }
+                      .select { |f| f.end_with?(".trb") || f.end_with?(".rb") }
+                      .reject { |f| @config.excluded?(f) }
       return if changed_files.empty? && removed.empty?
 
       puts
@@ -279,7 +279,7 @@ module TRuby
         file: file,
         line: line,
         col: col,
-        message: message
+        message: message,
       }
     end
 
@@ -287,7 +287,10 @@ module TRuby
       errors.each do |error|
         puts
         # TypeScript-style error format: file:line:col - error TSXXXX: message
-        location = "#{colorize(:cyan, relative_path(error[:file]))}:#{colorize(:yellow, error[:line])}:#{colorize(:yellow, error[:col])}"
+        location = "#{colorize(:cyan,
+                               relative_path(error[:file]))}:#{colorize(:yellow,
+                                                                        error[:line])}:#{colorize(:yellow,
+                                                                                                  error[:col])}"
         puts "#{location} - #{colorize(:red, "error")} #{colorize(:gray, "TRB0001")}: #{error[:message]}"
       end
     end
@@ -298,7 +301,8 @@ module TRuby
     end
 
     def print_file_change_message
-      puts "#{colorize(:gray, timestamp)} #{colorize(:bold, "File change detected. Starting incremental compilation...")}"
+      puts "#{colorize(:gray,
+                       timestamp)} #{colorize(:bold, "File change detected. Starting incremental compilation...")}"
       puts
     end
 
@@ -306,12 +310,11 @@ module TRuby
       puts
       if @error_count.zero?
         msg = "Found #{colorize(:green, "0 errors")}. Watching for file changes."
-        puts "#{colorize(:gray, timestamp)} #{msg}"
       else
         error_word = @error_count == 1 ? "error" : "errors"
         msg = "Found #{colorize(:red, "#{@error_count} #{error_word}")}. Watching for file changes."
-        puts "#{colorize(:gray, timestamp)} #{msg}"
       end
+      puts "#{colorize(:gray, timestamp)} #{msg}"
     end
 
     def print_watching_message
@@ -323,11 +326,12 @@ module TRuby
       puts "#{colorize(:gray, timestamp)} #{colorize(:bold, "Watch Mode Statistics:")}"
       puts "  Total compilations: #{@stats[:total_compilations]}"
       puts "  Incremental cache hits: #{@stats[:incremental_hits]}"
-      hit_rate = if @stats[:total_compilations] + @stats[:incremental_hits] > 0
-        (@stats[:incremental_hits].to_f / (@stats[:total_compilations] + @stats[:incremental_hits]) * 100).round(1)
-      else
-        0
-      end
+      total = @stats[:total_compilations] + @stats[:incremental_hits]
+      hit_rate = if total.positive?
+                   (@stats[:incremental_hits].to_f / total * 100).round(1)
+                 else
+                   0
+                 end
       puts "  Cache hit rate: #{hit_rate}%"
       puts "  Total compile time: #{@stats[:total_time].round(2)}s"
     end