RuleDefinition.n

using Nemerle.Collections;
using Nemerle.Text;
using Nemerle.Utility;
using Nemerle.Compiler;

using System;
using System.Collections.Generic;
using System.Linq;

namespace Nemerle.Parser.Model
{
  [Record]
  public variant RuleDefinition : Nemerle.Compiler.Located
  {
    public Id              : int                  { get; }
    public Name            : NameRef              { get; }
    public Attributes      : list[RuleAttribute]  { get; }
    public TokenFieldNames : Map[string, NameRef] { get; }

    public IsAst       : bool { get { Attributes.Exists(_ is RuleAttribute.Ast) } }
    public IsExtention : bool { get { this is RuleDefinition.ExtentionPrefix || this is RuleDefinition.ExtentionPostfix } }

    | ExtentionPoint   { retType : RuleType; }
    | ExtentionPrefix  { baseRuleName : NameRef; rule : Rule; }
    | ExtentionPostfix { baseRuleName : NameRef; bindingPower : int; rule : Rule; }
    | Simple           { retType : RuleType; rule : Rule; }
    | Regular          { rule : RegularRule; }
    | ExternalRule     { grammarRef : GrammarRef; isExtentionPoint : bool; }

    public GetRule() : option[Rule]
    {
      match (this)
      {
        | ExternalRule
        | Regular
        | ExtentionPoint         => None()
        | ExtentionPrefix as rd  => Some(rd.rule)
        | ExtentionPostfix as rd => Some(rd.rule)
        | Simple as rd           => Some(rd.rule)
      }
    }

    public GetSubRules() : list[Rule]
    {
      match (this)
      {
        | ExternalRule
        | Regular
        | ExtentionPoint         => []
        | ExtentionPrefix as rd  => rd.rule.GetSubRules()
        | ExtentionPostfix as rd => rd.rule.GetSubRules()
        | Simple as rd           => rd.rule.GetSubRules()
      }
    }

    public override Equals(that : object) : bool
    {
      match (that)
      {
        | that is RuleDefinition => Id == that.Id
        | _ => false
      }
    }

    public override GetHashCode() : int
    {
      Id.GetHashCode()
    }
  }
}