t-ruby 0.0.34 → 0.0.36

data/lib/t_ruby/error_handler.rb

@@ -69,7 +69,7 @@ module TRuby
         next unless line.match?(/^\s*def\s+/)
 
         # Check for unclosed parenthesis
-        if line.match?(/def\s+\w+\([^)]*$/) && !@lines[idx + 1..].any? { |l| l.match?(/\)/) }
+        if line.match?(/def\s+\w+\([^)]*$/) && @lines[(idx + 1)..].none? { |l| l.match?(/\)/) }
           @errors << "Line #{idx + 1}: Potential unclosed parenthesis in function definition"
         end
 
@@ -84,6 +84,7 @@ module TRuby
     def check_method_signature_errors
       @lines.each_with_index do |line, idx|
         next unless line.match?(/^\s*def\s+/)
+
         check_single_method_signature(line, idx)
       end
     end
@@ -96,7 +97,7 @@ 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*$/)
+      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"
@@ -112,13 +113,13 @@ module TRuby
       end
 
       # Pattern 4: Extract and validate return type
-      if match = line.match(/def\s+\w+\s*\([^)]*\)\s*:\s*(.+?)\s*$/)
+      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")
       end
 
       # Pattern 5: Extract and validate parameter types
-      if match = line.match(/def\s+\w+\s*\(([^)]+)\)/)
+      if (match = line.match(/def\s+\w+\s*\(([^)]+)\)/))
         params_str = match[1]
         validate_parameter_types_expression(params_str, idx)
       end
@@ -189,7 +190,7 @@ module TRuby
       # Use TypeParser to validate
       result = @type_parser.parse(type_str)
       if result[:success]
-        remaining = type_str[result[:position] || 0..]&.strip
+        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
@@ -207,17 +208,17 @@ module TRuby
         next if param.empty?
 
         # Check for param: Type pattern
-        if match = param.match(/^(\w+)\s*:\s*(.+)$/)
-          param_name = match[1]
-          type_str = match[2].strip
+        next unless (match = param.match(/^(\w+)\s*:\s*(.+)$/))
 
-          if type_str.empty?
-            @errors << "Line #{line_idx + 1}: Expected type after colon for parameter '#{param_name}'"
-            next
-          end
+        param_name = match[1]
+        type_str = match[2].strip
 
-          validate_type_expression(type_str, line_idx, "parameter type for '#{param_name}'")
+        if type_str.empty?
+          @errors << "Line #{line_idx + 1}: Expected type after colon for parameter '#{param_name}'"
+          next
         end
+
+        validate_type_expression(type_str, line_idx, "parameter type for '#{param_name}'")
       end
     end
 
@@ -235,7 +236,7 @@ module TRuby
           depth -= 1
           current += char
         when ","
-          if depth == 0
+          if depth.zero?
             result << current.strip
             current = ""
           else
@@ -262,10 +263,8 @@ module TRuby
         return_type = match[2]&.strip
 
         # Check return type if it's a simple type name
-        if return_type && return_type.match?(/^\w+$/)
-          unless VALID_TYPES.include?(return_type) || @type_aliases.key?(return_type)
-            @errors << "Line #{idx + 1}: Unknown return type '#{return_type}'"
-          end
+        if return_type&.match?(/^\w+$/) && !(VALID_TYPES.include?(return_type) || @type_aliases.key?(return_type))
+          @errors << "Line #{idx + 1}: Unknown return type '#{return_type}'"
         end
 
         # Check parameter types
@@ -286,10 +285,10 @@ module TRuby
         next unless param_type
 
         # Only check simple type names against VALID_TYPES
-        if param_type.match?(/^\w+$/)
-          next if VALID_TYPES.include?(param_type) || @type_aliases.key?(param_type)
-          @errors << "Line #{line_idx + 1}: Unknown parameter type '#{param_type}'"
-        end
+        next unless param_type.match?(/^\w+$/)
+        next if VALID_TYPES.include?(param_type) || @type_aliases.key?(param_type)
+
+        @errors << "Line #{line_idx + 1}: Unknown parameter type '#{param_type}'"
       end
     end
 

data/lib/t_ruby/generic_type_parser.rb

@@ -30,7 +30,7 @@ module TRuby
       {
         type: :generic,
         base: base_name,
-        params: params
+        params: params,
       }
     end
 
@@ -50,7 +50,7 @@ module TRuby
           depth -= 1
           current += char
         when ","
-          if depth == 0
+          if depth.zero?
             params << current.strip
             current = ""
           else
@@ -61,7 +61,7 @@ module TRuby
         end
       end
 
-      params << current.strip if current.length > 0
+      params << current.strip if current.length.positive?
       params
     end
   end

data/lib/t_ruby/intersection_type_parser.rb

@@ -17,13 +17,13 @@ module TRuby
     private
 
     def parse_intersection
-      members = @type_string.split("&").map { |m| m.strip }.compact
+      members = @type_string.split("&").map(&:strip).compact
 
       {
         type: :intersection,
         members: members,
         has_duplicates: members.length != members.uniq.length,
-        unique_members: members.uniq
+        unique_members: members.uniq,
       }
     end
   end

data/lib/t_ruby/ir.rb

@@ -314,7 +314,7 @@ module TRuby
       attr_accessor :kind, :condition, :body
 
       # kind: :while, :until, :loop
-      def initialize(kind:, condition: nil, body:, **opts)
+      def initialize(kind:, body:, condition: nil, **opts)
         super(**opts)
         @kind = kind
         @condition = condition
@@ -424,7 +424,7 @@ module TRuby
     class Lambda < Node
       attr_accessor :params, :body, :return_type
 
-      def initialize(params: [], body:, return_type: nil, **opts)
+      def initialize(body:, params: [], return_type: nil, **opts)
         super(**opts)
         @params = params
         @body = body
@@ -457,7 +457,7 @@ module TRuby
     class RescueClause < Node
       attr_accessor :exception_types, :variable, :body
 
-      def initialize(exception_types: [], variable: nil, body:, **opts)
+      def initialize(body:, exception_types: [], variable: nil, **opts)
         super(**opts)
         @exception_types = exception_types
         @variable = variable
@@ -523,11 +523,11 @@ module TRuby
       end
 
       def to_rbs
-        "#{@base}[#{@type_args.map(&:to_rbs).join(', ')}]"
+        "#{@base}[#{@type_args.map(&:to_rbs).join(", ")}]"
       end
 
       def to_trb
-        "#{@base}<#{@type_args.map(&:to_trb).join(', ')}>"
+        "#{@base}<#{@type_args.map(&:to_trb).join(", ")}>"
       end
     end
 
@@ -571,7 +571,7 @@ module TRuby
     class FunctionType < TypeNode
       attr_accessor :param_types, :return_type
 
-      def initialize(param_types: [], return_type:, **opts)
+      def initialize(return_type:, param_types: [], **opts)
         super(**opts)
         @param_types = param_types
         @return_type = return_type
@@ -598,11 +598,11 @@ module TRuby
       end
 
       def to_rbs
-        "[#{@element_types.map(&:to_rbs).join(', ')}]"
+        "[#{@element_types.map(&:to_rbs).join(", ")}]"
       end
 
       def to_trb
-        "[#{@element_types.map(&:to_trb).join(', ')}]"
+        "[#{@element_types.map(&:to_trb).join(", ")}]"
       end
     end
 
@@ -648,7 +648,7 @@ module TRuby
 
     class Visitor
       def visit(node)
-        method_name = "visit_#{node.class.name.split('::').last.gsub(/([A-Z])/, '_\1').downcase.sub(/^_/, '')}"
+        method_name = "visit_#{node.class.name.split("::").last.gsub(/([A-Z])/, '_\1').downcase.sub(/^_/, "")}"
         if respond_to?(method_name)
           send(method_name, node)
         else
@@ -676,11 +676,9 @@ module TRuby
 
       # Build IR from parser output
       def build(parse_result, source: nil)
-        declarations = []
-
         # Build type aliases
-        (parse_result[:type_aliases] || []).each do |alias_info|
-          declarations << build_type_alias(alias_info)
+        declarations = (parse_result[:type_aliases] || []).map do |alias_info|
+          build_type_alias(alias_info)
         end
 
         # Build interfaces
@@ -802,7 +800,7 @@ module TRuby
             depth -= 1
             current += char
           when ","
-            if depth == 0
+            if depth.zero?
               args << parse_type(current.strip)
               current = ""
             else
@@ -912,7 +910,7 @@ module TRuby
       private
 
       def emit(text)
-        @output << ("  " * @indent + text)
+        @output << (("  " * @indent) + text)
       end
 
       def emit_comment(text)
@@ -1008,7 +1006,7 @@ module TRuby
       private
 
       def emit(text)
-        @output << ("  " * @indent + text)
+        @output << (("  " * @indent) + text)
       end
     end
 
@@ -1141,12 +1139,11 @@ module TRuby
           when "+" then left + right
           when "-" then left - right
           when "*" then left * right
-          when "/" then right != 0 ? left / right : nil
-          when "%" then right != 0 ? left % right : nil
-          when "**" then left ** right
-          else nil
+          when "/" then right.zero? ? nil : left / right
+          when "%" then right.zero? ? nil : left % right
+          when "**" then left**right
           end
-        rescue
+        rescue StandardError
           nil
         end
       end
@@ -1176,7 +1173,7 @@ module TRuby
 
         private
 
-        def redundant_annotation?(param)
+        def redundant_annotation?(_param)
           # Consider annotation redundant if it matches the default/inferred type
           false
         end
@@ -1264,7 +1261,7 @@ module TRuby
         Passes::DeadCodeElimination,
         Passes::ConstantFolding,
         Passes::TypeAnnotationCleanup,
-        Passes::UnusedDeclarationRemoval
+        Passes::UnusedDeclarationRemoval,
       ].freeze
 
       attr_reader :passes, :stats
@@ -1291,7 +1288,7 @@ module TRuby
           end
 
           @stats[:total_changes] += changes_this_iteration
-          break if changes_this_iteration == 0
+          break if changes_this_iteration.zero?
         end
 
         { program: program, stats: @stats }