collie 0.1.0 → 1.0.0

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

@@ -15,29 +15,65 @@ module Collie
         def check(ast, context = {})
           symbol_table = context[:symbol_table] || build_symbol_table(ast)
 
-          ast.rules.each do |rule|
+          each_rule_like(ast) do |rule|
+            allowed_symbols = rule_like_parameters(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
+              alt.symbols.each { |symbol| check_symbol(symbol_table, symbol, allowed_symbols: allowed_symbols) }
             end
           end
 
+          check_declarations(ast, symbol_table)
+
           @offenses
         end
 
         private
 
+        def check_declarations(ast, symbol_table)
+          ast.declarations.each do |decl|
+            case decl
+            when AST::StartDeclaration
+              next if symbol_table.nonterminal?(decl.symbol)
+
+              add_offense(decl, message: "Undefined start symbol '#{decl.symbol}'")
+            when AST::TypeDeclaration
+              decl.names.each do |name|
+                next if symbol_table.declared?(name)
+
+                add_offense(decl, message: "%type references undefined symbol '#{name}'")
+              end
+            end
+          end
+        end
+
+        def check_symbol(symbol_table, symbol, allowed_symbols: [])
+          unless allowed_symbols.include?(symbol.name) || symbol_table.declared?(symbol.name)
+            add_offense(symbol,
+                        message: "Undefined symbol '#{symbol.name}'")
+          end
+
+          symbol.arguments&.each do |argument|
+            check_symbol(symbol_table, argument, allowed_symbols: allowed_symbols)
+          end
+        end
+
         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) }
+              decl.names.each do |name|
+                add_token(table, name, type_tag: decl.type_tag, location: decl.location)
+              end
+            when AST::PrecedenceDeclaration
+              decl.tokens.each do |name|
+                add_token(table, name, location: decl.location)
+              end
+            when AST::ParameterizedRule
+              table.add_nonterminal(decl.name, location: decl.location)
+            when AST::InlineRule
+              table.add_nonterminal(decl.rule, location: decl.location)
             end
           end
 
@@ -47,6 +83,12 @@ module Collie
 
           table
         end
+
+        def add_token(table, name, type_tag: nil, location: nil)
+          table.add_token(name, type_tag: type_tag, location: location)
+        rescue Error
+          # Ignore duplicates while building the resolver table.
+        end
       end
     end
   end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "set"
+
 require_relative "../base"
 
 module Collie
@@ -20,6 +22,29 @@ module Collie
             symbol_table.add_nonterminal(rule.name, location: rule.location)
           end
 
+          ast.declarations.each do |decl|
+            case decl
+            when AST::TokenDeclaration
+              decl.names.each do |name|
+                symbol_table.add_token(name, type_tag: decl.type_tag, location: decl.location)
+              rescue Error
+                # Ignore duplicates while building the resolver table.
+              end
+            when AST::PrecedenceDeclaration
+              decl.tokens.each do |name|
+                symbol_table.add_token(name, location: decl.location)
+              rescue Error
+                # Ignore duplicates while building the resolver table.
+              end
+            when AST::ParameterizedRule
+              symbol_table.add_nonterminal(decl.name, location: decl.location)
+            when AST::InlineRule
+              symbol_table.add_nonterminal(decl.rule, location: decl.location)
+            end
+          end
+
+          Analyzer::SymbolResolver.resolve(ast, symbol_table)
+
           # Find start symbol
           start_symbol = find_start_symbol(ast)
 
@@ -42,7 +67,7 @@ module Collie
 
           # Track nonterminal usage in parameterized rules (%rule)
           ast.declarations.each do |decl|
-            next unless decl.is_a?(AST::ParameterizedRule)
+            next unless decl.is_a?(AST::ParameterizedRule) || decl.is_a?(AST::InlineRule)
 
             decl.alternatives.each do |alt|
               alt.symbols.each do |symbol|
@@ -60,11 +85,13 @@ module Collie
 
           # Mark start symbol as used
           symbol_table.use_nonterminal(start_symbol) if start_symbol
+          unreachable_rules = unreachable_rules(ast, start_symbol)
 
           # Find unused nonterminals
           symbol_table.unused_nonterminals.each do |nonterminal_name|
             # Skip start symbol
             next if nonterminal_name == start_symbol
+            next if unreachable_rules.include?(nonterminal_name)
 
             rule = ast.rules.find { |r| r.name == nonterminal_name }
             next unless rule
@@ -85,6 +112,14 @@ module Collie
           # Default to first rule
           ast.rules.first&.name
         end
+
+        def unreachable_rules(ast, start_symbol)
+          return Set.new unless start_symbol
+
+          analyzer = Analyzer::Reachability.new(ast)
+          analyzer.analyze(start_symbol)
+          analyzer.unreachable_rules
+        end
       end
     end
   end

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

@@ -14,24 +14,23 @@ module Collie
 
         def check(ast, context = {})
           symbol_table = context[:symbol_table] || build_symbol_table(ast)
+          Analyzer::SymbolResolver.resolve(ast, symbol_table)
 
           # 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
+              alt.symbols.each { |symbol| mark_token_usage(symbol_table, symbol) }
+              mark_precedence_usage(symbol_table, alt)
             end
           end
 
           # Track token usage in parameterized rules (%rule)
           ast.declarations.each do |decl|
-            next unless decl.is_a?(AST::ParameterizedRule)
+            next unless decl.is_a?(AST::ParameterizedRule) || decl.is_a?(AST::InlineRule)
 
             decl.alternatives.each do |alt|
-              alt.symbols.each do |symbol|
-                symbol_table.use_token(symbol.name) if symbol.terminal?
-              end
+              alt.symbols.each { |symbol| mark_token_usage(symbol_table, symbol) }
+              mark_precedence_usage(symbol_table, alt)
             end
           end
 
@@ -46,6 +45,15 @@ module Collie
 
         private
 
+        def mark_token_usage(symbol_table, symbol)
+          symbol_table.use_token(symbol.name) if symbol.terminal?
+          symbol.arguments&.each { |argument| mark_token_usage(symbol_table, argument) }
+        end
+
+        def mark_precedence_usage(symbol_table, alternative)
+          symbol_table.use_token(alternative.prec) if alternative.prec
+        end
+
         def build_symbol_table(ast)
           table = Analyzer::SymbolTable.new
 
@@ -55,7 +63,13 @@ module Collie
               decl.names.each do |name|
                 table.add_token(name, type_tag: decl.type_tag, location: decl.location)
               rescue Error
-                # Ignore duplicates
+                # Ignore duplicates while building the resolver table.
+              end
+            when AST::PrecedenceDeclaration
+              decl.tokens.each do |name|
+                table.add_token(name, location: decl.location)
+              rescue Error
+                # Ignore duplicates while building the resolver table.
               end
             end
           end
@@ -66,7 +80,7 @@ module Collie
         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)
+            token_declares?(d, token_name)
           end
 
           return unless decl
@@ -74,6 +88,17 @@ module Collie
           add_offense(decl,
                       message: "Token '#{token_name}' is declared but never used")
         end
+
+        def token_declares?(declaration, token_name)
+          case declaration
+          when AST::TokenDeclaration
+            declaration.names.include?(token_name)
+          when AST::PrecedenceDeclaration
+            declaration.tokens.include?(token_name)
+          else
+            false
+          end
+        end
       end
     end
   end

data/lib/collie/parser/debug_serializer.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require_relative "../ast"
+
+module Collie
+  module Parser
+    # Serializes parser internals for CLI debug commands.
+    module DebugSerializer
+      class << self
+        def token(token)
+          {
+            type: token.type,
+            value: token.value,
+            raw_value: token.raw_value,
+            location: location(token.location)
+          }
+        end
+
+        def ast(node)
+          return nil unless node
+
+          case node
+          when AST::GrammarFile
+            grammar_file(node)
+          when AST::Prologue, AST::Epilogue
+            code_node(node)
+          when AST::TokenDeclaration
+            token_declaration(node)
+          when AST::TypeDeclaration
+            type_declaration(node)
+          when AST::PrecedenceDeclaration
+            precedence_declaration(node)
+          when AST::StartDeclaration
+            start_declaration(node)
+          when AST::UnionDeclaration
+            union_declaration(node)
+          when AST::UnknownDeclaration
+            unknown_declaration(node)
+          when AST::Rule
+            rule(node)
+          when AST::ParameterizedRule
+            parameterized_rule(node)
+          when AST::InlineRule
+            inline_rule(node)
+          when AST::Alternative
+            alternative(node)
+          when AST::Symbol
+            symbol(node)
+          when AST::Action
+            action(node)
+          else
+            { type: node.class.name }
+          end
+        end
+
+        private
+
+        def grammar_file(node)
+          {
+            type: "GrammarFile",
+            prologue: ast(node.prologue),
+            declarations: node.declarations.map { |declaration| ast(declaration) },
+            rules: node.rules.map { |rule| ast(rule) },
+            epilogue: ast(node.epilogue),
+            location: location(node.location)
+          }
+        end
+
+        def code_node(node)
+          {
+            type: node_type(node),
+            code: node.code,
+            location: location(node.location)
+          }
+        end
+
+        def token_declaration(node)
+          {
+            type: "TokenDeclaration",
+            names: node.names,
+            type_tag: node.type_tag,
+            location: location(node.location)
+          }
+        end
+
+        def type_declaration(node)
+          {
+            type: "TypeDeclaration",
+            names: node.names,
+            type_tag: node.type_tag,
+            location: location(node.location)
+          }
+        end
+
+        def precedence_declaration(node)
+          {
+            type: "PrecedenceDeclaration",
+            associativity: node.associativity,
+            tokens: node.tokens,
+            location: location(node.location)
+          }
+        end
+
+        def start_declaration(node)
+          {
+            type: "StartDeclaration",
+            symbol: node.symbol,
+            location: location(node.location)
+          }
+        end
+
+        def union_declaration(node)
+          {
+            type: "UnionDeclaration",
+            body: node.body,
+            location: location(node.location)
+          }
+        end
+
+        def unknown_declaration(node)
+          {
+            type: "UnknownDeclaration",
+            source: node.source,
+            location: location(node.location)
+          }
+        end
+
+        def rule(node)
+          {
+            type: "Rule",
+            name: node.name,
+            alternatives: node.alternatives.map { |alternative| ast(alternative) },
+            location: location(node.location)
+          }
+        end
+
+        def parameterized_rule(node)
+          {
+            type: "ParameterizedRule",
+            name: node.name,
+            parameters: node.parameters,
+            alternatives: node.alternatives.map { |alternative| ast(alternative) },
+            location: location(node.location)
+          }
+        end
+
+        def inline_rule(node)
+          {
+            type: "InlineRule",
+            rule: node.rule,
+            parameters: node.parameters,
+            alternatives: node.alternatives.map { |alternative| ast(alternative) },
+            location: location(node.location)
+          }
+        end
+
+        def alternative(node)
+          {
+            type: "Alternative",
+            symbols: node.symbols.map { |symbol| ast(symbol) },
+            action: ast(node.action),
+            prec: node.prec,
+            explicit_empty: node.explicit_empty,
+            empty_marker: node.empty_marker,
+            location: location(node.location)
+          }
+        end
+
+        def symbol(node)
+          {
+            type: "Symbol",
+            name: node.name,
+            kind: node.kind,
+            alias_name: node.alias_name,
+            arguments: node.arguments&.map { |argument| ast(argument) },
+            location: location(node.location)
+          }
+        end
+
+        def action(node)
+          {
+            type: "Action",
+            code: node.code,
+            location: location(node.location)
+          }
+        end
+
+        def node_type(node)
+          node.class.name.split("::").last
+        end
+
+        def location(location)
+          return nil unless location
+
+          {
+            file: location.file,
+            line: location.line,
+            column: location.column,
+            length: location.length
+          }
+        end
+      end
+    end
+  end
+end