collie 0.1.0 → 1.0.0

data/lib/collie/linter/rules/ambiguous_precedence.rb

@@ -53,8 +53,10 @@ module Collie
         def collect_operators(ast)
           operators = Hash.new { |h, k| h[k] = [] }
 
-          ast.rules.each do |rule|
+          each_rule_like(ast) do |rule|
             rule.alternatives.each do |alt|
+              next if alt.prec
+
               alt.symbols.each do |symbol|
                 next unless symbol.terminal?
                 next unless looks_like_operator?(symbol.name)
@@ -75,7 +77,8 @@ module Collie
           offense = Offense.new(
             rule: self.class,
             location: location,
-            message: message
+            message: message,
+            severity: configured_severity
           )
           @offenses << offense
         end

data/lib/collie/linter/rules/circular_reference.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "set"
+
 module Collie
   module Linter
     module Rules
@@ -12,14 +14,16 @@ module Collie
 
         def check(ast, _context = {})
           @rules_map = build_rules_map(ast)
-          @visited = Set.new
-          @rec_stack = Set.new
+          @dependencies = build_dependency_graph
+          productive_rules = compute_productive_rules
 
-          ast.rules.each do |rule|
-            next if @visited.include?(rule.name)
+          strongly_connected_components.each do |component|
+            next unless cyclic_component?(component)
+            next if component.any? { |rule_name| productive_rules.include?(rule_name) }
 
-            if has_cycle?(rule.name, [])
-              add_offense(rule, message: "Rule '#{rule.name}' is part of a circular reference")
+            component.each do |rule_name|
+              rule = @rules_map[rule_name]
+              add_offense(rule, message: "Rule '#{rule_name}' is part of a non-productive circular reference") if rule
             end
           end
 
@@ -29,57 +33,111 @@ module Collie
         private
 
         def build_rules_map(ast)
-          ast.rules.each_with_object({}) do |rule, map|
-            map[rule.name] = rule
+          rules = ast.rules + ast.declarations.select do |decl|
+            decl.is_a?(AST::ParameterizedRule) || decl.is_a?(AST::InlineRule)
           end
-        end
 
-        def has_cycle?(rule_name, path)
-          return false if @visited.include?(rule_name)
+          rules.each_with_object({}) do |rule, map|
+            map[rule_name(rule)] = rule
+          end
+        end
 
-          if @rec_stack.include?(rule_name)
-            # Found a cycle - check if it's truly circular (no terminals in alternatives)
-            return true if pure_nonterminal_cycle?(rule_name)
+        def rule_name(rule)
+          rule.is_a?(AST::InlineRule) ? rule.rule : rule.name
+        end
 
-            return false
+        def build_dependency_graph
+          @rules_map.transform_values do |rule|
+            rule.alternatives.each_with_object(Set.new) do |alternative, dependencies|
+              alternative.symbols.each { |symbol| collect_dependencies(symbol, dependencies) }
+            end
           end
+        end
+
+        def collect_dependencies(symbol, dependencies)
+          dependencies << symbol.name if symbol.nonterminal? && @rules_map.key?(symbol.name)
+          symbol.arguments&.each { |argument| collect_dependencies(argument, dependencies) }
+        end
+
+        def compute_productive_rules
+          productive = Set.new
+
+          loop do
+            changed = false
+
+            @rules_map.each do |name, rule|
+              next if productive.include?(name)
+              next unless rule.alternatives.any? { |alternative| productive_alternative?(alternative, productive) }
 
-          @rec_stack.add(rule_name)
-          current_path = path + [rule_name]
+              productive << name
+              changed = true
+            end
+
+            break unless changed
+          end
 
-          rule = @rules_map[rule_name]
-          # Check each alternative - only follow nonterminals
-          rule&.alternatives&.each do |alt|
-            # Skip alternatives with terminals or empty alternatives
-            next if has_terminal_or_empty?(alt)
+          productive
+        end
 
-            # Only check the first symbol for cycles
-            first_symbol = alt.symbols.first
-            next unless first_symbol&.nonterminal?
+        def productive_alternative?(alternative, productive_rules)
+          return true if alternative.explicit_empty || alternative.symbols.empty?
 
-            return true if has_cycle?(first_symbol.name, current_path)
+          alternative.symbols.all? do |symbol|
+            productive_symbol?(symbol, productive_rules)
           end
+        end
 
-          @rec_stack.delete(rule_name)
-          @visited.add(rule_name)
+        def productive_symbol?(symbol, productive_rules)
+          return true if symbol.terminal?
 
-          false
+          symbol.nonterminal? && productive_rules.include?(symbol.name)
         end
 
-        def has_terminal_or_empty?(alternative)
-          return true if alternative.symbols.empty?
+        def strongly_connected_components
+          @index = 0
+          @indices = {}
+          @lowlinks = {}
+          @stack = []
+          @on_stack = Set.new
+          components = []
+
+          @rules_map.each_key do |rule_name|
+            strong_connect(rule_name, components) unless @indices.key?(rule_name)
+          end
 
-          alternative.symbols.any?(&:terminal?)
+          components
         end
 
-        def pure_nonterminal_cycle?(rule_name)
-          rule = @rules_map[rule_name]
-          return false unless rule
+        def strong_connect(rule_name, components)
+          @indices[rule_name] = @index
+          @lowlinks[rule_name] = @index
+          @index += 1
+          @stack << rule_name
+          @on_stack << rule_name
+
+          @dependencies[rule_name].each do |dependency|
+            if !@indices.key?(dependency)
+              strong_connect(dependency, components)
+              @lowlinks[rule_name] = [@lowlinks[rule_name], @lowlinks[dependency]].min
+            elsif @on_stack.include?(dependency)
+              @lowlinks[rule_name] = [@lowlinks[rule_name], @indices[dependency]].min
+            end
+          end
+
+          return unless @lowlinks[rule_name] == @indices[rule_name]
 
-          # Check if all alternatives contain only nonterminals
-          rule.alternatives.all? do |alt|
-            !has_terminal_or_empty?(alt)
+          component = []
+          loop do
+            dependency = @stack.pop
+            @on_stack.delete(dependency)
+            component << dependency
+            break if dependency == rule_name
           end
+          components << component
+        end
+
+        def cyclic_component?(component)
+          component.size > 1 || @dependencies[component.first].include?(component.first)
         end
       end
     end

data/lib/collie/linter/rules/consistent_tag_naming.rb

@@ -17,7 +17,7 @@ module Collie
           styles = tags.group_by { |tag, _| detect_style(tag) }
 
           # If we have multiple styles, report inconsistency
-          add_inconsistency_offense(ast, styles) if styles.size > 1
+          add_inconsistency_offenses(styles) if styles.size > 1
 
           @offenses
         end
@@ -45,21 +45,21 @@ module Collie
           :other
         end
 
-        def add_inconsistency_offense(ast, styles)
+        Node = Struct.new(:location)
+
+        def add_inconsistency_offenses(styles)
           style_names = styles.keys.map(&:to_s).join(", ")
           most_common_style = styles.max_by { |_, tags| tags.size }[0]
+          expected_tags = styles.fetch(most_common_style)
+          outliers = styles.reject { |style, _| style == most_common_style }.values.flatten(1)
 
-          # Add offense at the first declaration
-          first_decl = ast.declarations.first
-          location = first_decl&.location || AST::Location.new(file: "grammar", line: 1, column: 1)
-
-          offense = Offense.new(
-            rule: self.class,
-            location: location,
-            message: "Inconsistent type tag naming styles detected (#{style_names}). " \
-                     "Consider using #{most_common_style} throughout."
-          )
-          @offenses << offense
+          outliers.each do |tag, location|
+            add_offense(
+              Node.new(location || expected_tags.first[1] || AST::Location.new(file: "grammar", line: 1, column: 1)),
+              message: "Type tag '#{tag}' uses a different naming style (#{style_names}). " \
+                       "Consider using #{most_common_style} throughout."
+            )
+          end
         end
       end
     end

data/lib/collie/linter/rules/empty_action.rb

@@ -10,9 +10,9 @@ module Collie
         self.severity = :convention
         self.autocorrectable = true
 
-        def check(ast, _context = {})
-          ast.rules.each do |rule|
-            check_rule(rule)
+        def check(ast, context = {})
+          each_rule_like(ast) do |rule|
+            check_rule(rule, context)
           end
 
           @offenses
@@ -20,30 +20,61 @@ module Collie
 
         private
 
-        def check_rule(rule)
+        def check_rule(rule, context)
           rule.alternatives.each do |alt|
             next unless alt.action
             next unless empty_action?(alt.action)
 
             add_offense(
-              alt,
+              alt.action,
               message: "Empty action block can be removed",
-              autocorrect: -> { remove_action(alt) }
+              autocorrect: -> { remove_action(alt, context) }
             )
           end
         end
 
         def empty_action?(action)
-          # Check if action code is empty or contains only whitespace
-          return true unless action.code
-          return true if action.code.strip.empty?
+          code = action.code.to_s.strip
+          return true if code.empty?
 
-          false
+          action_body = if code.start_with?("{") && code.end_with?("}")
+                          code[1...-1].strip
+                        else
+                          code
+                        end
+
+          action_body.empty?
         end
 
-        def remove_action(alternative)
+        def remove_action(alternative, context)
+          action = alternative.action
+          if context[:source] && action&.location
+            context[:source] = remove_action_from_source(context[:source], action.location)
+          end
+
           alternative.action = nil
         end
+
+        def remove_action_from_source(source, location)
+          index = source_index(source, location)
+          return source unless index
+
+          prefix = source[0...index].sub(/[ \t]*\z/, "")
+          suffix = source[(index + location.length)..] || ""
+          "#{prefix}#{suffix}"
+        end
+
+        def source_index(source, location)
+          offset = 0
+
+          source.each_line.with_index(1) do |line, line_number|
+            return offset + location.column - 1 if line_number == location.line
+
+            offset += line.length
+          end
+
+          nil
+        end
       end
     end
   end

data/lib/collie/linter/rules/factorizable_rules.rb

@@ -13,7 +13,7 @@ module Collie
         MIN_PREFIX_LENGTH = 2
 
         def check(ast, _context = {})
-          ast.rules.each do |rule|
+          each_rule_like(ast) do |rule|
             check_rule(rule)
           end
 
@@ -37,7 +37,7 @@ module Collie
 
             add_offense(
               rule,
-              message: "Rule '#{rule.name}' has #{alternatives.size} alternatives with common prefix " \
+              message: "Rule '#{rule_like_name(rule)}' has #{alternatives.size} alternatives with common prefix " \
                        "(#{prefix_length} symbols). Consider factoring."
             )
             break # Only report once per rule

data/lib/collie/linter/rules/left_recursion.rb

@@ -6,8 +6,8 @@ module Collie
       # Detects left recursion in grammar rules
       class LeftRecursion < Base
         self.rule_name = "LeftRecursion"
-        self.description = "Detects left recursion (may cause issues with some parsers)"
-        self.severity = :warning
+        self.description = "Notes left recursion for LL parser portability"
+        self.severity = :info
         self.autocorrectable = false
 
         def check(ast, _context = {})
@@ -15,12 +15,13 @@ module Collie
           result = analyzer.analyze
 
           result[:left_recursive].each do |rule_name|
-            rule = ast.rules.find { |r| r.name == rule_name }
+            rule = find_rule_like(ast, rule_name)
             next unless rule
 
             add_offense(
               rule,
-              message: "Rule '#{rule_name}' uses left recursion (consider using right recursion for LL parsers)"
+              message: "Rule '#{rule_name}' uses left recursion. This is normal for LR parsers; " \
+                       "review only if targeting LL parser portability."
             )
           end
 

data/lib/collie/linter/rules/long_rule.rb

@@ -13,16 +13,16 @@ module Collie
         DEFAULT_MAX_ALTERNATIVES = 10
 
         def check(ast, _context = {})
-          max_alternatives = @config.dig("rules", "LongRule", "max_alternatives") || DEFAULT_MAX_ALTERNATIVES
+          max_alternatives = config_value(:max_alternatives, DEFAULT_MAX_ALTERNATIVES)
 
-          ast.rules.each do |rule|
+          each_rule_like(ast) do |rule|
             alternatives_count = rule.alternatives.size
 
             next unless alternatives_count > max_alternatives
 
             add_offense(
               rule,
-              message: "Rule '#{rule.name}' has #{alternatives_count} alternatives " \
+              message: "Rule '#{rule_like_name(rule)}' has #{alternatives_count} alternatives " \
                        "(max: #{max_alternatives}). Consider refactoring."
             )
           end

data/lib/collie/linter/rules/nonterminal_naming.rb

@@ -15,13 +15,15 @@ module Collie
         DEFAULT_PATTERN = /^[a-z][a-z0-9_]*$/
 
         def check(ast, _context = {})
-          pattern = @config[:pattern] ? Regexp.new(@config[:pattern]) : DEFAULT_PATTERN
+          pattern_config = config_value(:pattern)
+          pattern = pattern_config ? Regexp.new(pattern_config) : DEFAULT_PATTERN
 
-          ast.rules.each do |rule|
-            next if rule.name.match?(pattern)
+          each_rule_like(ast) do |rule|
+            name = rule_like_name(rule)
+            next if name.match?(pattern)
 
             add_offense(rule,
-                        message: "Nonterminal '#{rule.name}' should match pattern #{pattern.inspect}")
+                        message: "Nonterminal '#{name}' should match pattern #{pattern.inspect}")
           end
 
           @offenses

data/lib/collie/linter/rules/prec_improvement.rb

@@ -13,7 +13,7 @@ module Collie
         def check(ast, _context = {})
           precedence_tokens = collect_precedence_tokens(ast)
 
-          ast.rules.each do |rule|
+          each_rule_like(ast) do |rule|
             check_rule(rule, precedence_tokens)
           end
 

data/lib/collie/linter/rules/redundant_epsilon.rb

@@ -6,12 +6,12 @@ module Collie
       # Detects potentially redundant epsilon productions
       class RedundantEpsilon < Base
         self.rule_name = "RedundantEpsilon"
-        self.description = "Detects potentially redundant epsilon (empty) productions"
+        self.description = "Detects duplicate epsilon (empty) productions"
         self.severity = :info
         self.autocorrectable = false
 
         def check(ast, _context = {})
-          ast.rules.each do |rule|
+          each_rule_like(ast) do |rule|
             check_rule(rule)
           end
 
@@ -21,21 +21,21 @@ module Collie
         private
 
         def check_rule(rule)
-          epsilon_alternatives = rule.alternatives.select { |alt| alt.symbols.empty? }
-          return if epsilon_alternatives.empty?
+          epsilon_alternatives = rule.alternatives.select { |alt| epsilon?(alt) }
+          return if epsilon_alternatives.size < 2
 
-          # Only report if there are other non-epsilon alternatives
-          non_epsilon_alternatives = rule.alternatives.reject { |alt| alt.symbols.empty? }
-          return if non_epsilon_alternatives.empty?
-
-          epsilon_alternatives.each do |alt|
+          epsilon_alternatives.drop(1).each do |alt|
             add_offense(
               alt,
-              message: "Rule '#{rule.name}' has an epsilon production. " \
-                       "Verify if it's necessary or if the rule can be made optional elsewhere."
+              message: "Rule '#{rule_like_name(rule)}' has multiple epsilon productions. " \
+                       "Keep one empty alternative and remove duplicates."
             )
           end
         end
+
+        def epsilon?(alternative)
+          alternative.symbols.empty? || alternative.explicit_empty
+        end
       end
     end
   end

data/lib/collie/linter/rules/right_recursion.rb

@@ -13,9 +13,12 @@ module Collie
         def check(ast, _context = {})
           analyzer = Analyzer::Recursion.new(ast)
           result = analyzer.analyze
+          left_recursive = result[:left_recursive]
 
           result[:right_recursive].each do |rule_name|
-            rule = ast.rules.find { |r| r.name == rule_name }
+            next if left_recursive.include?(rule_name)
+
+            rule = find_rule_like(ast, rule_name)
             next unless rule
 
             add_offense(

data/lib/collie/linter/rules/symbol_conflict.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Collie
+  module Linter
+    module Rules
+      # Detects conflicting grammar symbol declarations.
+      class SymbolConflict < Base
+        self.rule_name = "SymbolConflict"
+        self.description = "Detects conflicting token and nonterminal declarations"
+        self.severity = :error
+        self.autocorrectable = false
+
+        def check(ast, _context = {})
+          tokens = collect_tokens(ast)
+          nonterminals = collect_nonterminals(ast)
+          precedence_tokens = collect_precedence_tokens(ast)
+
+          report_token_nonterminal_conflicts(tokens, nonterminals)
+          report_duplicate_nonterminals(nonterminals)
+          report_duplicate_precedence_tokens(precedence_tokens)
+
+          @offenses
+        end
+
+        private
+
+        Entry = Struct.new(:name, :location)
+
+        def collect_tokens(ast)
+          ast.declarations.each_with_object({}) do |decl, tokens|
+            token_names(decl).each do |name|
+              tokens[name] ||= Entry.new(name, decl.location)
+            end
+          end
+        end
+
+        def token_names(declaration)
+          case declaration
+          when AST::TokenDeclaration
+            declaration.names
+          when AST::PrecedenceDeclaration
+            declaration.tokens
+          else
+            []
+          end
+        end
+
+        def collect_nonterminals(ast)
+          entries = []
+
+          ast.declarations.each do |decl|
+            case decl
+            when AST::ParameterizedRule
+              entries << Entry.new(decl.name, decl.location)
+            when AST::InlineRule
+              entries << Entry.new(decl.rule, decl.location)
+            end
+          end
+
+          ast.rules.each do |rule|
+            entries << Entry.new(rule.name, rule.location)
+          end
+
+          entries
+        end
+
+        def collect_precedence_tokens(ast)
+          entries = []
+
+          ast.declarations.each do |decl|
+            next unless decl.is_a?(AST::PrecedenceDeclaration)
+
+            decl.tokens.each do |name|
+              entries << Entry.new(name, decl.location)
+            end
+          end
+
+          entries
+        end
+
+        def report_token_nonterminal_conflicts(tokens, nonterminals)
+          nonterminals.each do |entry|
+            next unless tokens.key?(entry.name)
+
+            add_offense(
+              Node.new(entry.location),
+              message: "Symbol '#{entry.name}' is declared as both token and nonterminal"
+            )
+          end
+        end
+
+        def report_duplicate_nonterminals(nonterminals)
+          seen = {}
+
+          nonterminals.each do |entry|
+            if seen.key?(entry.name)
+              add_offense(
+                Node.new(entry.location),
+                message: "Nonterminal '#{entry.name}' already defined at #{seen[entry.name]}"
+              )
+            else
+              seen[entry.name] = entry.location
+            end
+          end
+        end
+
+        def report_duplicate_precedence_tokens(precedence_tokens)
+          seen = {}
+
+          precedence_tokens.each do |entry|
+            if seen.key?(entry.name)
+              add_offense(
+                Node.new(entry.location),
+                message: "Precedence token '#{entry.name}' already declared at #{seen[entry.name]}"
+              )
+            else
+              seen[entry.name] = entry.location
+            end
+          end
+        end
+
+        Node = Struct.new(:location)
+      end
+    end
+  end
+end
+
+Collie::Linter::Registry.register(Collie::Linter::Rules::SymbolConflict)

data/lib/collie/linter/rules/token_naming.rb

@@ -15,7 +15,8 @@ module Collie
         DEFAULT_PATTERN = /^[A-Z][A-Z0-9_]*$/
 
         def check(ast, _context = {})
-          pattern = @config[:pattern] ? Regexp.new(@config[:pattern]) : DEFAULT_PATTERN
+          pattern_config = config_value(:pattern)
+          pattern = pattern_config ? Regexp.new(pattern_config) : DEFAULT_PATTERN
 
           ast.declarations.each do |decl|
             next unless decl.is_a?(AST::TokenDeclaration)

data/lib/collie/linter/rules/trailing_whitespace.rb

@@ -31,13 +31,19 @@ module Collie
               Node.new(location),
               message: "Trailing whitespace detected",
               autocorrect: lambda {
-                context[:source] = source.gsub(/[ \t]+\n/, "\n").gsub(/[ \t]+$/, "")
+                context[:source] = remove_trailing_whitespace(context[:source] || source)
               }
             )
           end
 
           @offenses
         end
+
+        private
+
+        def remove_trailing_whitespace(source)
+          source.gsub(/[ \t]+\n/, "\n").gsub(/[ \t]+$/, "")
+        end
       end
     end
   end