rename id

Author: a

src/Metatheory.jl

@@ -3,10 +3,10 @@ module Metatheory
 using Base.Meta
 using Reexport
 
-const EClassId = UInt64
+const Id = UInt64
 # TODO document bindings
-const EMatchBindings = Base.ImmutableDict{Int,Tuple{EClassId,Int}}
-const UNDEF_ID_VEC = Vector{EClassId}(undef, 0)
+const EMatchBindings = Base.ImmutableDict{Int,Tuple{Id,Int}}
+const UNDEF_ID_VEC = Vector{Id}(undef, 0)
 
 @inline alwaystrue(x) = true
 
@@ -30,7 +30,7 @@ include("uniquequeue.jl")
 
 include("egraph.jl")
 export ENode
-export EClassId
+export Id
 export EClass
 export find
 export lookup

src/egraph.jl

@@ -35,7 +35,7 @@ struct ENode
   istree::Bool
   head::Any
   operation::Any
-  args::Vector{EClassId}
+  args::Vector{Id}
   hash::Ref{UInt}
   ENode(head, operation, args) = new(true, head, operation, args, Ref{UInt}(0))
   ENode(literal) = new(false, nothing, literal, UNDEF_ID_VEC, Ref{UInt}(0))
@@ -79,9 +79,9 @@ end
 
 # parametrize metadata by M
 mutable struct EClass{D}
-  id::EClassId
+  id::Id
   nodes::Vector{ENode}
-  parents::Vector{Pair{ENode,EClassId}}
+  parents::Vector{Pair{ENode,Id}}
   data::Union{D,Nothing}
 end
 
@@ -101,7 +101,7 @@ function Base.show(io::IO, a::EClass)
   print(io, ")")
 end
 
-function addparent!(@nospecialize(a::EClass), n::ENode, id::EClassId)
+function addparent!(@nospecialize(a::EClass), n::ENode, id::Id)
   push!(a.parents, (n => id))
 end
 
@@ -134,22 +134,22 @@ mutable struct EGraph{Head,Analysis}
   "stores the equality relations over e-class ids"
   uf::UnionFind
   "map from eclass id to eclasses"
-  classes::Dict{EClassId,EClass{Analysis}}
+  classes::Dict{Id,EClass{Analysis}}
   "hashcons"
-  memo::Dict{ENode,EClassId}
+  memo::Dict{ENode,Id}
   "Nodes which need to be processed for rebuilding. The id is the id of the enode, not the canonical id of the eclass."
-  pending::Vector{Pair{ENode,EClassId}}
-  analysis_pending::UniqueQueue{Pair{ENode,EClassId}}
-  root::EClassId
+  pending::Vector{Pair{ENode,Id}}
+  analysis_pending::UniqueQueue{Pair{ENode,Id}}
+  root::Id
   "a cache mapping function symbols and their arity to e-classes that contain e-nodes with that function symbol."
-  classes_by_op::Dict{Pair{Any,Int},Vector{EClassId}}
+  classes_by_op::Dict{Pair{Any,Int},Vector{Id}}
   clean::Bool
   "If we use global buffers we may need to lock. Defaults to false."
   needslock::Bool
   "Buffer for e-matching which defaults to a global. Use a local buffer for generated functions."
   buffer::Vector{EMatchBindings}
   "Buffer for rule application which defaults to a global. Use a local buffer for generated functions."
-  merges_buffer::Vector{EClassId}
+  merges_buffer::Vector{Id}
   lock::ReentrantLock
 end
 
@@ -161,16 +161,16 @@ Construct an EGraph from a starting symbolic expression `expr`.
 function EGraph{Head,Analysis}(; needslock::Bool = false) where {Head,Analysis}
   EGraph{Head,Analysis}(
     UnionFind(),
-    Dict{EClassId,EClass{Analysis}}(),
-    Dict{ENode,EClassId}(),
-    Pair{ENode,EClassId}[],
-    UniqueQueue{Pair{ENode,EClassId}}(),
+    Dict{Id,EClass{Analysis}}(),
+    Dict{ENode,Id}(),
+    Pair{ENode,Id}[],
+    UniqueQueue{Pair{ENode,Id}}(),
     0,
-    Dict{Pair{Any,Int},Vector{EClassId}}(),
+    Dict{Pair{Any,Int},Vector{Id}}(),
     false,
     needslock,
     EMatchBindings[],
-    EClassId[],
+    Id[],
     ReentrantLock(),
   )
 end
@@ -199,16 +199,16 @@ end
 """
 Returns the canonical e-class id for a given e-class.
 """
-@inline find(g::EGraph, a::EClassId)::EClassId = find(g.uf, a)
-@inline find(@nospecialize(g::EGraph), @nospecialize(a::EClass))::EClassId = find(g, a.id)
+@inline find(g::EGraph, a::Id)::Id = find(g.uf, a)
+@inline find(@nospecialize(g::EGraph), @nospecialize(a::EClass))::Id = find(g, a.id)
 
-@inline Base.getindex(@nospecialize(g::EGraph), i::EClassId)::EClass = g.classes[find(g, i)]
+@inline Base.getindex(@nospecialize(g::EGraph), i::Id)::EClass = g.classes[find(g, i)]
 
 function canonicalize(g::EGraph, n::ENode)::ENode
   n.istree || return n
   ar = length(n.args)
   ar == 0 && return n
-  canonicalized_args = Vector{EClassId}(undef, ar)
+  canonicalized_args = Vector{Id}(undef, ar)
   for i in 1:ar
     @inbounds canonicalized_args[i] = find(g, n.args[i])
   end
@@ -224,7 +224,7 @@ function canonicalize!(g::EGraph, n::ENode)
   return n
 end
 
-function lookup(g::EGraph, n::ENode)::EClassId
+function lookup(g::EGraph, n::ENode)::Id
   cc = canonicalize(g, n)
   haskey(g.memo, cc) ? find(g, g.memo[cc]) : 0
 end
@@ -242,7 +242,7 @@ end
 """
 Inserts an e-node in an [`EGraph`](@ref)
 """
-function add!(g::EGraph{Head,Analysis}, n::ENode)::EClassId where {Head,Analysis}
+function add!(g::EGraph{Head,Analysis}, n::ENode)::Id where {Head,Analysis}
   n = canonicalize(g, n)
   haskey(g.memo, n) && return g.memo[n]
 
@@ -257,7 +257,7 @@ function add!(g::EGraph{Head,Analysis}, n::ENode)::EClassId where {Head,Analysis
   g.memo[n] = id
 
   add_class_by_op(g, n, id)
-  eclass = EClass{Analysis}(id, ENode[n], Pair{ENode,EClassId}[], make(g, n))
+  eclass = EClass{Analysis}(id, ENode[n], Pair{ENode,Id}[], make(g, n))
   g.classes[id] = eclass
   modify!(g, eclass)
   push!(g.pending, n => id)
@@ -282,14 +282,14 @@ Recursively traverse an type satisfying the `TermInterface` and insert terms int
 [`EGraph`](@ref). If `e` has no children (has an arity of 0) then directly
 insert the literal into the [`EGraph`](@ref).
 """
-function addexpr!(g::EGraph, se)::EClassId
+function addexpr!(g::EGraph, se)::Id
   se isa EClass && return se.id
   e = preprocess(se)
 
   n = if istree(se)
     args = arguments(e)
     ar = arity(e)
-    class_ids = Vector{EClassId}(undef, ar)
+    class_ids = Vector{Id}(undef, ar)
     for i in 1:ar
       @inbounds class_ids[i] = addexpr!(g, args[i])
     end
@@ -305,7 +305,7 @@ end
 Given an [`EGraph`](@ref) and two e-class ids, set
 the two e-classes as equal.
 """
-function Base.union!(g::EGraph, enode_id1::EClassId, enode_id2::EClassId)::Bool
+function Base.union!(g::EGraph, enode_id1::Id, enode_id2::Id)::Bool
   g.clean = false
 
   id_1 = find(g, enode_id1)
@@ -335,7 +335,7 @@ function Base.union!(g::EGraph, enode_id1::EClassId, enode_id2::EClassId)::Bool
   return true
 end
 
-function in_same_class(g::EGraph, ids::EClassId...)::Bool
+function in_same_class(g::EGraph, ids::Id...)::Bool
   nids = length(ids)
   nids == 1 && return true
 
@@ -377,7 +377,7 @@ function process_unions!(@nospecialize(g::EGraph))::Int
 
   while !isempty(g.pending) || !isempty(g.analysis_pending)
     while !isempty(g.pending)
-      (node::ENode, eclass_id::EClassId) = pop!(g.pending)
+      (node::ENode, eclass_id::Id) = pop!(g.pending)
       canonicalize!(g, node)
       if haskey(g.memo, node)
         old_class_id = g.memo[node]
@@ -390,7 +390,7 @@ function process_unions!(@nospecialize(g::EGraph))::Int
     end
 
     while !isempty(g.analysis_pending)
-      (node::ENode, eclass_id::EClassId) = pop!(g.analysis_pending)
+      (node::ENode, eclass_id::Id) = pop!(g.analysis_pending)
       eclass_id = find(g, eclass_id)
       eclass = g[eclass_id]
 
@@ -414,7 +414,7 @@ function process_unions!(@nospecialize(g::EGraph))::Int
 end
 
 function check_memo(g::EGraph)::Bool
-  test_memo = Dict{ENode,EClassId}()
+  test_memo = Dict{ENode,Id}()
   for (id, class) in g.classes
     @assert id == class.id
     for node in class.nodes
@@ -463,10 +463,10 @@ end
 Recursive function that traverses an [`EGraph`](@ref) and
 returns a vector of all reachable e-classes from a given e-class id.
 """
-function reachable(g::EGraph, id::EClassId)
+function reachable(g::EGraph, id::Id)
   id = find(g, id)
-  hist = EClassId[id]
-  todo = EClassId[id]
+  hist = Id[id]
+  todo = Id[id]
 
 
   function reachable_node(xn::ENode)
@@ -493,7 +493,7 @@ end
 
 import Metatheory: lookup_pat
 
-function lookup_pat(g::EGraph{Head}, p::PatTerm)::EClassId where {Head}
+function lookup_pat(g::EGraph{Head}, p::PatTerm)::Id where {Head}
   @assert isground(p)
 
   op = operation(p)
@@ -502,7 +502,7 @@ function lookup_pat(g::EGraph{Head}, p::PatTerm)::EClassId where {Head}
 
   eh = Head(head_symbol(head(p)))
 
-  ids = Vector{EClassId}(undef, ar)
+  ids = Vector{Id}(undef, ar)
   for i in 1:ar
     @inbounds ids[i] = lookup_pat(g, args[i])
     ids[i] <= 0 && return 0
@@ -516,20 +516,20 @@ function lookup_pat(g::EGraph{Head}, p::PatTerm)::EClassId where {Head}
   end
 end
 
-lookup_pat(g::EGraph, p::Any)::EClassId = lookup(g, ENode(p))
+lookup_pat(g::EGraph, p::Any)::Id = lookup(g, ENode(p))
 
 struct Extractor{CostFun,Cost}
   g::EGraph
   cost_function::CostFun
-  costs::Dict{EClassId,Tuple{Cost,Int64}} # Cost and index in eclass
+  costs::Dict{Id,Tuple{Cost,Int64}} # Cost and index in eclass
 end
 
 """
 Given a cost function, extract the expression
 with the smallest computed cost from an [`EGraph`](@ref)
 """
 function Extractor(g::EGraph, cost_function::Function, cost_type = Float64)
-  extractor = Extractor{typeof(cost_function),cost_type}(g, cost_function, Dict{EClassId,Tuple{cost_type,Int}}())
+  extractor = Extractor{typeof(cost_function),cost_type}(g, cost_function, Dict{Id,Tuple{cost_type,Int}}())
   find_costs!(extractor)
   extractor
 end
@@ -546,13 +546,13 @@ end
 
 
 function (extractor::Extractor)(root = extractor.g.root)
-  get_node(eclass_id::EClassId) = find_best_node(extractor, eclass_id)
+  get_node(eclass_id::Id) = find_best_node(extractor, eclass_id)
   # TODO check if infinite cost?
   extract_expr_recursive(find_best_node(extractor, root), get_node)
 end
 
 # costs dict stores index of enode. get this enode from the eclass
-function find_best_node(extractor::Extractor, eclass_id::EClassId)
+function find_best_node(extractor::Extractor, eclass_id::Id)
   eclass = extractor.g[eclass_id]
   (_, node_index) = extractor.costs[eclass.id]
   eclass.nodes[node_index]

src/egraph_matcher_compiler.jl

@@ -2,7 +2,7 @@ module EMatchCompiler
 
 using ..TermInterface
 using ..Patterns
-using Metatheory: islist, car, cdr, drop_n, lookup_pat, LL, maybelock!, EMatchBindings, EGraph, ENode, EClassId
+using Metatheory: islist, car, cdr, drop_n, lookup_pat, LL, maybelock!, EMatchBindings, EGraph, ENode, Id
 export ematcher_yield, ematcher_yield_bidir
 
 
@@ -139,7 +139,7 @@ The rest of the immutable dictionary bindings[n>0] represents (e-class id, liter
 """
 function ematcher_yield(p, npvars::Int, direction::Int)
   em = ematcher(p)
-  function _ematcher_yield(g::EGraph, rule_idx::Int, id::EClassId)::Int
+  function _ematcher_yield(g::EGraph, rule_idx::Int, id::Id)::Int
     n_matches = 0
     em(g, (id,), EMPTY_BINDINGS) do bindings::EMatchBindings, n
       maybelock!(g) do
@@ -155,7 +155,7 @@ ematcher_yield(p, npvars) = ematcher_yield(p, npvars, 1)
 
 function ematcher_yield_bidir(l, r, npvars::Int)
   eml, emr = ematcher_yield(l, npvars, 1), ematcher_yield(r, npvars, -1)
-  function _ematcher_yield_bidir(g::EGraph, rule_idx::Int, id::EClassId)::Int
+  function _ematcher_yield_bidir(g::EGraph, rule_idx::Int, id::Id)::Int
     eml(g, rule_idx, id) + emr(g, rule_idx, id)
   end
 end

src/saturation.jl

@@ -38,7 +38,7 @@ Base.@kwdef mutable struct SaturationParams
   timer::Bool                          = true
 end
 
-function cached_ids(g::EGraph, p::PatTerm)::Vector{EClassId}
+function cached_ids(g::EGraph, p::PatTerm)::Vector{Id}
   if isground(p)
     id = lookup_pat(g, p)
     !isnothing(id) && return [id]
@@ -98,15 +98,15 @@ function eqsat_search!(
   return n_matches
 end
 
-instantiate_enode!(bindings::EMatchBindings, @nospecialize(g::EGraph), p::Any)::EClassId = add!(g, ENode(p))
-instantiate_enode!(bindings::EMatchBindings, @nospecialize(g::EGraph), p::PatVar)::EClassId = bindings[p.idx][1]
-function instantiate_enode!(bindings::EMatchBindings, g::EGraph{Head}, p::PatTerm)::EClassId where {Head}
+instantiate_enode!(bindings::EMatchBindings, @nospecialize(g::EGraph), p::Any)::Id = add!(g, ENode(p))
+instantiate_enode!(bindings::EMatchBindings, @nospecialize(g::EGraph), p::PatVar)::Id = bindings[p.idx][1]
+function instantiate_enode!(bindings::EMatchBindings, g::EGraph{Head}, p::PatTerm)::Id where {Head}
   op = operation(p)
   args = arguments(p)
   # TODO handle this situation better
   new_op = Head == ExprHead && op isa Union{Function,DataType} ? nameof(op) : op
   eh = Head(head_symbol(head(p)))
-  nargs = Vector{EClassId}(undef, length(args))
+  nargs = Vector{Id}(undef, length(args))
   for i in 1:length(args)
     @inbounds nargs[i] = instantiate_enode!(bindings, g, args[i])
   end
@@ -120,15 +120,15 @@ function apply_rule!(buf, g::EGraph, rule::RewriteRule, id, direction)
   nothing
 end
 
-function apply_rule!(bindings::EMatchBindings, g::EGraph, rule::EqualityRule, id::EClassId, direction::Int)
+function apply_rule!(bindings::EMatchBindings, g::EGraph, rule::EqualityRule, id::Id, direction::Int)
   pat_to_inst = direction == 1 ? rule.right : rule.left
   push!(g.merges_buffer, id)
   push!(g.merges_buffer, instantiate_enode!(bindings, g, pat_to_inst))
   nothing
 end
 
 
-function apply_rule!(bindings::EMatchBindings, g::EGraph, rule::UnequalRule, id::EClassId, direction::Int)
+function apply_rule!(bindings::EMatchBindings, g::EGraph, rule::UnequalRule, id::Id, direction::Int)
   pat_to_inst = direction == 1 ? rule.right : rule.left
   other_id = instantiate_enode!(bindings, g, pat_to_inst)
 
@@ -153,7 +153,7 @@ function instantiate_actual_param!(bindings::EMatchBindings, g::EGraph, i)
   return eclass
 end
 
-function apply_rule!(bindings::EMatchBindings, g::EGraph, rule::DynamicRule, id::EClassId, direction::Int)
+function apply_rule!(bindings::EMatchBindings, g::EGraph, rule::DynamicRule, id::Id, direction::Int)
   f = rule.rhs_fun
   r = f(id, g, (instantiate_actual_param!(bindings, g, i) for i in 1:length(rule.patvars))...)
   isnothing(r) && return nothing