collie 0.1.0

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Collie
+  module Linter
+    module Rules
+      # Suggests improvements for %prec usage
+      class PrecImprovement < Base
+        self.rule_name = "PrecImprovement"
+        self.description = "Suggests improvements for %prec directive usage"
+        self.severity = :info
+        self.autocorrectable = false
+
+        def check(ast, _context = {})
+          precedence_tokens = collect_precedence_tokens(ast)
+
+          ast.rules.each do |rule|
+            check_rule(rule, precedence_tokens)
+          end
+
+          @offenses
+        end
+
+        private
+
+        def collect_precedence_tokens(ast)
+          tokens = []
+          ast.declarations.each do |decl|
+            next unless decl.is_a?(AST::PrecedenceDeclaration)
+
+            tokens.concat(decl.tokens)
+          end
+          tokens
+        end
+
+        def check_rule(rule, precedence_tokens)
+          rule.alternatives.each do |alt|
+            next unless alt.prec
+
+            # Check if the %prec token has a precedence declaration
+            next if precedence_tokens.include?(alt.prec)
+
+            add_offense(
+              alt,
+              message: "%%prec token '#{alt.prec}' is not declared in precedence directives. " \
+                       "Consider adding it to %left, %right, or %nonassoc."
+            )
+          end
+        end
+      end
+    end
+  end
+end
+
+Collie::Linter::Registry.register(Collie::Linter::Rules::PrecImprovement)

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Collie
+  module Linter
+    module Rules
+      # Detects potentially redundant epsilon productions
+      class RedundantEpsilon < Base
+        self.rule_name = "RedundantEpsilon"
+        self.description = "Detects potentially redundant epsilon (empty) productions"
+        self.severity = :info
+        self.autocorrectable = false
+
+        def check(ast, _context = {})
+          ast.rules.each do |rule|
+            check_rule(rule)
+          end
+
+          @offenses
+        end
+
+        private
+
+        def check_rule(rule)
+          epsilon_alternatives = rule.alternatives.select { |alt| alt.symbols.empty? }
+          return if epsilon_alternatives.empty?
+
+          # 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|
+            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."
+            )
+          end
+        end
+      end
+    end
+  end
+end
+
+Collie::Linter::Registry.register(Collie::Linter::Rules::RedundantEpsilon)

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Collie
+  module Linter
+    module Rules
+      # Detects right recursion and suggests left recursion conversion
+      class RightRecursion < Base
+        self.rule_name = "RightRecursion"
+        self.description = "Detects right recursion (consider converting to left recursion for LR parsers)"
+        self.severity = :warning
+        self.autocorrectable = false
+
+        def check(ast, _context = {})
+          analyzer = Analyzer::Recursion.new(ast)
+          result = analyzer.analyze
+
+          result[:right_recursive].each do |rule_name|
+            rule = ast.rules.find { |r| r.name == rule_name }
+            next unless rule
+
+            add_offense(
+              rule,
+              message: "Rule '#{rule_name}' uses right recursion " \
+                       "(consider left recursion for better LR parser performance)"
+            )
+          end
+
+          @offenses
+        end
+      end
+    end
+  end
+end
+
+Collie::Linter::Registry.register(Collie::Linter::Rules::RightRecursion)

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Collie
+  module Linter
+    module Rules
+      # Checks token naming conventions
+      class TokenNaming < Base
+        self.rule_name = "TokenNaming"
+        self.description = "Tokens should follow UPPER_CASE naming convention"
+        self.severity = :convention
+        self.autocorrectable = false
+
+        DEFAULT_PATTERN = /^[A-Z][A-Z0-9_]*$/
+
+        def check(ast, _context = {})
+          pattern = @config[:pattern] ? Regexp.new(@config[:pattern]) : DEFAULT_PATTERN
+
+          ast.declarations.each do |decl|
+            next unless decl.is_a?(AST::TokenDeclaration)
+
+            decl.names.each do |name|
+              next if name.match?(pattern)
+              next if name.start_with?('"', "'") # Skip literals
+
+              add_offense(decl,
+                          message: "Token '#{name}' should match pattern #{pattern.inspect}")
+            end
+          end
+
+          @offenses
+        end
+      end
+    end
+  end
+end
+
+Collie::Linter::Registry.register(Collie::Linter::Rules::TokenNaming)

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Collie
+  module Linter
+    module Rules
+      # Detects trailing whitespace in source code
+      class TrailingWhitespace < Base
+        self.rule_name = "TrailingWhitespace"
+        self.description = "Detects trailing whitespace at the end of lines"
+        self.severity = :convention
+        self.autocorrectable = true
+
+        # Simple node class for holding location
+        Node = Struct.new(:location)
+
+        def check(_ast, context = {})
+          source = context[:source]
+          return @offenses unless source
+
+          source.lines.each_with_index do |line, index|
+            line_number = index + 1
+            next unless line.match?(/[ \t]+\n$|[ \t]+$/)
+
+            location = AST::Location.new(
+              file: context[:file] || "grammar",
+              line: line_number,
+              column: line.rstrip.length + 1
+            )
+
+            add_offense(
+              Node.new(location),
+              message: "Trailing whitespace detected",
+              autocorrect: lambda {
+                context[:source] = source.gsub(/[ \t]+\n/, "\n").gsub(/[ \t]+$/, "")
+              }
+            )
+          end
+
+          @offenses
+        end
+      end
+    end
+  end
+end
+
+Collie::Linter::Registry.register(Collie::Linter::Rules::TrailingWhitespace)

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Collie
+  module Linter
+    module Rules
+      # Detects references to undeclared tokens or nonterminals
+      class UndefinedSymbol < Base
+        self.rule_name = "UndefinedSymbol"
+        self.description = "Detects references to undeclared tokens or nonterminals"
+        self.severity = :error
+        self.autocorrectable = false
+
+        def check(ast, context = {})
+          symbol_table = context[:symbol_table] || build_symbol_table(ast)
+
+          ast.rules.each do |rule|
+            rule.alternatives.each do |alt|
+              alt.symbols.each do |symbol|
+                next if symbol_table.declared?(symbol.name)
+
+                add_offense(symbol,
+                            message: "Undefined symbol '#{symbol.name}'")
+              end
+            end
+          end
+
+          @offenses
+        end
+
+        private
+
+        def build_symbol_table(ast)
+          table = Analyzer::SymbolTable.new
+
+          ast.declarations.each do |decl|
+            case decl
+            when AST::TokenDeclaration
+              decl.names.each { |name| table.add_token(name, type_tag: decl.type_tag, location: decl.location) }
+            end
+          end
+
+          ast.rules.each do |rule|
+            table.add_nonterminal(rule.name, location: rule.location)
+          end
+
+          table
+        end
+      end
+    end
+  end
+end
+
+Collie::Linter::Registry.register(Collie::Linter::Rules::UndefinedSymbol)

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Collie
+  module Linter
+    module Rules
+      # Detects rules that are not reachable from the start symbol
+      class UnreachableRule < Base
+        self.rule_name = "UnreachableRule"
+        self.description = "Detects rules that are not reachable from the start symbol"
+        self.severity = :warning
+        self.autocorrectable = false
+
+        def check(ast, _context = {})
+          return @offenses if ast.rules.empty?
+
+          analyzer = Analyzer::Reachability.new(ast)
+          start_symbol = find_start_symbol(ast)
+          analyzer.analyze(start_symbol)
+
+          unreachable = analyzer.unreachable_rules
+
+          unreachable.each do |rule_name|
+            rule = ast.rules.find { |r| r.name == rule_name }
+            next unless rule
+
+            add_offense(rule,
+                        message: "Rule '#{rule_name}' is not reachable from start symbol '#{start_symbol}'")
+          end
+
+          @offenses
+        end
+
+        private
+
+        def find_start_symbol(ast)
+          start_decl = ast.declarations.find { |d| d.is_a?(AST::StartDeclaration) }
+          return start_decl.symbol if start_decl
+
+          # Default to first rule
+          ast.rules.first&.name
+        end
+      end
+    end
+  end
+end
+
+Collie::Linter::Registry.register(Collie::Linter::Rules::UnreachableRule)

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Collie
+  module Linter
+    module Rules
+      # Detects nonterminals that are defined but never referenced
+      class UnusedNonterminal < Base
+        self.rule_name = "UnusedNonterminal"
+        self.description = "Detects nonterminals that are defined but never referenced"
+        self.severity = :warning
+        self.autocorrectable = false
+
+        def check(ast, _context = {})
+          symbol_table = Analyzer::SymbolTable.new
+
+          # Register all nonterminals
+          ast.rules.each do |rule|
+            symbol_table.add_nonterminal(rule.name, location: rule.location)
+          end
+
+          # Find start symbol
+          start_symbol = find_start_symbol(ast)
+
+          # Track nonterminal usage in normal rules
+          ast.rules.each do |rule|
+            rule.alternatives.each do |alt|
+              alt.symbols.each do |symbol|
+                if symbol.nonterminal?
+                  symbol_table.use_nonterminal(symbol.name)
+                  # Also consider parameterized rule call arguments: list(expr)
+                  if symbol.arguments
+                    symbol.arguments.each do |arg|
+                      symbol_table.use_nonterminal(arg.name) if arg.nonterminal?
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          # Track nonterminal usage in parameterized rules (%rule)
+          ast.declarations.each do |decl|
+            next unless decl.is_a?(AST::ParameterizedRule)
+
+            decl.alternatives.each do |alt|
+              alt.symbols.each do |symbol|
+                if symbol.nonterminal?
+                  symbol_table.use_nonterminal(symbol.name)
+                  if symbol.arguments
+                    symbol.arguments.each do |arg|
+                      symbol_table.use_nonterminal(arg.name) if arg.nonterminal?
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          # Mark start symbol as used
+          symbol_table.use_nonterminal(start_symbol) if start_symbol
+
+          # Find unused nonterminals
+          symbol_table.unused_nonterminals.each do |nonterminal_name|
+            # Skip start symbol
+            next if nonterminal_name == start_symbol
+
+            rule = ast.rules.find { |r| r.name == nonterminal_name }
+            next unless rule
+
+            add_offense(rule,
+                        message: "Nonterminal '#{nonterminal_name}' is defined but never used")
+          end
+
+          @offenses
+        end
+
+        private
+
+        def find_start_symbol(ast)
+          start_decl = ast.declarations.find { |d| d.is_a?(AST::StartDeclaration) }
+          return start_decl.symbol if start_decl
+
+          # Default to first rule
+          ast.rules.first&.name
+        end
+      end
+    end
+  end
+end
+
+Collie::Linter::Registry.register(Collie::Linter::Rules::UnusedNonterminal)

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Collie
+  module Linter
+    module Rules
+      # Detects tokens that are declared but never used
+      class UnusedToken < Base
+        self.rule_name = "UnusedToken"
+        self.description = "Detects tokens that are declared but never used in rules"
+        self.severity = :warning
+        self.autocorrectable = false
+
+        def check(ast, context = {})
+          symbol_table = context[:symbol_table] || build_symbol_table(ast)
+
+          # Track token usage in normal rules
+          ast.rules.each do |rule|
+            rule.alternatives.each do |alt|
+              alt.symbols.each do |symbol|
+                symbol_table.use_token(symbol.name) if symbol.terminal?
+              end
+            end
+          end
+
+          # Track token usage in parameterized rules (%rule)
+          ast.declarations.each do |decl|
+            next unless decl.is_a?(AST::ParameterizedRule)
+
+            decl.alternatives.each do |alt|
+              alt.symbols.each do |symbol|
+                symbol_table.use_token(symbol.name) if symbol.terminal?
+              end
+            end
+          end
+
+          # Find unused tokens
+          symbol_table.unused_tokens.each do |token_name|
+            token_info = symbol_table.tokens[token_name]
+            add_offense_for_declaration(ast, token_name, token_info[:location])
+          end
+
+          @offenses
+        end
+
+        private
+
+        def build_symbol_table(ast)
+          table = Analyzer::SymbolTable.new
+
+          ast.declarations.each do |decl|
+            case decl
+            when AST::TokenDeclaration
+              decl.names.each do |name|
+                table.add_token(name, type_tag: decl.type_tag, location: decl.location)
+              rescue Error
+                # Ignore duplicates
+              end
+            end
+          end
+
+          table
+        end
+
+        def add_offense_for_declaration(ast, token_name, _location)
+          # Find the declaration node
+          decl = ast.declarations.find do |d|
+            d.is_a?(AST::TokenDeclaration) && d.names.include?(token_name)
+          end
+
+          return unless decl
+
+          add_offense(decl,
+                      message: "Token '#{token_name}' is declared but never used")
+        end
+      end
+    end
+  end
+end
+
+Collie::Linter::Registry.register(Collie::Linter::Rules::UnusedToken)