Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

Nautomaton
CAutomatonBase
CDFA
CDFANode
CLt
CNFA
CNFANode
CLt
CRangeCompare
Nmim
Nast
CAliasDecl	anx dbg = path; - a compiler-exposed alias sharing its target's annex slot
CAliasPtrn	ptrn as dbg
CAnnexInfo	Bookkeeping of an annex introduced by an AxmDecl
C[struct].sym
C[struct].id
CAppExpr	callee arg
CAST	Owns the arena all AST nodes live in as well as the AnnexInfos of all plugins
CForeignAlias	An anx alias in one plugin for an annex of another, e.g. anx M = core.M; in mem
CFiles
CAxmDecl	axm dbg: type, normalizer, curry, trip; or a family axm (name, ...): type, normalizer, curry, trip;
CName	dbg = alias_0 = ... = alias_n-1 - one axiom of the family, which each of its names binds to
CBind	One name in a Scope: the Decl it introduces and the Vis of this binding
CDecl	Base class of all declarations; caches the emitted Decl::def
CDeclExpr	decls expr or expr where decls if DeclExpr::is_where
CDummyDecl
CEmitter
CNomInfo
CErrorExpr	Erroneous expression
CErrorPtrn	Erroneous pattern
CExpr	Base class of all expressions
CFile	The AST of one source file: an anonymous ModDecl that a UseDecl binds under a name of its own
CGrpPtrn	dbg_i of a group dbg_0 ... dbg_n-1: type for i > 0; the leading IdPtrn::id owns type
CHoleExpr	?
CIdDecl	dbg bound to a Def whose type the binding construct dictates; hence, it carries no annotation
CIdPtrn	dbg: type
CInfixExpr	lhs op rhs; InfixExpr::op picks the meaning - see MIM_INFIX
CLamDecl	tag dbg dom_0 ... dom_n-1: codom = body; with LamDecl::tag lam/con/fun or anonymous λ/cn/fn
CDom	One dom of a LamDecl: ptrn@(filter) with an optional : ret type
CLamExpr	Wraps a LamDecl as Expr
CLetDecl	let ptrn = value;
CLexer
CLitExpr	tok:type
CMatchExpr	match scrutinee with | arm_0 | ... | arm_n-1
CArm	ptrn => body, ctor ptrn => body, or index [ptrn] => body of a MatchExpr
CModDecl	mod dbg decls end; also the base of the anonymous File
CMods	Raw, unvalidated combination of priv/pub/extern/anx modifiers written before a declaration
CMutualDecl	mutual decl* end groups RecDecls that may refer to each other
CNode	Base class of all AST nodes
CNomDecl	nom dbg = body; - a nominal newtype
CParser	Parses Mim code as AST
CPath	dbg_0.....dbg_n-1
CPathExpr	path
CPiExpr	dom → codom, Cn dom, or Fn dom → codom depending on PiExpr::tag
CDom	One dom of a PiExpr: ptrn with an optional -> ret type
CPrefixExpr	op rhs; PrefixExpr::op picks the meaning - see MIM_PREFIX
CPrimaryExpr	tag
CPtrn	Base class of all patterns
CR
CRecDecl	rec dbg = body;
CRetExpr	ret ptrn = callee $ arg; body
CRuleDecl	rule dbg var: lhs when guard => rhs; or norm instead of rule if RuleDecl::is_normalizer
CRuleExpr	Rule dom
CS
CScopes
CBarrier
CSeqExpr	«index: shape; body» or ‹index: shape; body› if SeqExpr::is_pack; index: is optional
CSigmaExpr	Wraps a TuplePtrn as Expr
CSingleExpr	«body» or ‹body› if SingleExpr::is_wrap
CTok
CTupleExpr	(elem_0, ..., elem_n-1)
CTuplePtrn	(ptrn_0, ..., ptrn_n-1), [ptrn_0, ..., ptrn_n-1], or {ptrn_0, ..., ptrn_n-1}
CTypeExpr	Type level
CUseDecl	import "file"|name [as alias|*];, plugin name [as alias|*];, or use path [as alias|*]; as * splices instead of naming; a use without an as is sugar for as *
CValDecl	Base class of all declarations that bind values
CVariantExpr	| ctor_0: type_0 | ... | ctor_n-1: type_n-1; a constructor without a type carries []
CCtor	dbg: type of a VariantExpr
Nplug
Naffine	The affine Plugin
Nphase
CLowerFor	Lowers the for axm to actual control flow in CPS
CLowerIndex	Lowers the affine index algebra to core arithmetic
Nautodiff	The automatic differentiation Plugin
Nphase
CEval	This phase is the heart of AD
Nbtensor	The btensor Plugin
Nphase
CLowerMapReduce	Lowers the buffer-world operations (btensor.map_reduce_post, btensor.broadcast, btensor.pad, btensor.concat, btensor.gather, btensor.scatter) into affine.For loop nests over buffer.read / buffer.write / buffer.alloc, threading mem.M
CMapRedPost	The curried meta arguments of a tensor.map_reduce_post or btensor.map_reduce_post callee (same layout)
CRanks
CRing_field	The fields of btensor.Ring, by index
CSched_field	The fields of btensor.Sched, by index
Nbuffer	The buffer Plugin
CLowerPtr	Lowers the buffer abstraction to the low-level pointer representation
Nclos	The clos Plugin
Nphase
CBranchClosElim	Flattens branches over closure literals back into a direct branch over Lams
CClos2SJLJ	Lowers basicblock closures that are passed as arguments (i.e
CClosConv	Performs typed closure conversion, rebuilding the old world into a new one
CClosConvPrep	Wraps operands with the clos.anno annotations (returning, free_bb, fstclass_bb, ...) and eta-expands branches and continuations so that ClosConv sees a canonical program
CFreeDefAna	Computes, on demand and with memoization, the free Defs that a Lam must capture in its closure environment
CLowerTypedClos	This pass lowers typed closures to untyped closures
CLowerTypedClosPrep	Escape analysis for closures: closure literals get their function wrapped in clos.anno.esc or clos.anno.bottom, depending on whether their environment escapes
CClosLit	Lightweight, non-owning view onto a closure literal (env_type, fn, env); see isa_clos_lit
Ncps	The CPS Plugin
CConv	Full CPS conversion in one recursive rewrite
Ngpu	The gpu Plugin
Nphase
CLowerMapReduce
CMemChecks
CRemoveDoubleSyncs
CSplitApply
CSplitOffKernels	Afterwards, old_world() is the host, which keeps each kernel as a declaration, and new_world() the device
Nll	The ll Plugin
CBB
CEmit	Pipeline phase for ll.emit
CEmitter
Nmem	The mem Plugin
Nphase
CAddMem	Threads the mem.M memory monad through the world: mem-extends continuations and rewires every memory operand to the current memory at that program point
CFreeLocals	Frees the memory a function allocates but does not let escape; see mem::EscapeAnalysis
CHeap2Stack	Turns a mem.alloc that does not escape its function (see mem::EscapeAnalysis) into a mem.slot
CSEO	Symbolic Expression Optimization
CEscapeAnalysis	Determines which allocations stay within the scope that allocates them
CChain
Nnvptx	The nvptx Plugin
CDeviceEmitFlags
CDeviceEmitter
CEmit
CHostEmitter
Noption	The option Plugin
COpt_ctor	The ctors of option.Opt, by index
Nord	The ord Plugin
CKey_field	The fields of ord.Key, by index
Nregex	The regex Plugin
Capp_range
CLowerRegex	Lowers a regex axm application to a DFA matcher function
Ntensor	The tensor Plugin
Nphase
CFuse
CLeaf	A chain operand; the chain reads its transpose if t
CLower	Lowers the high-level tensor axioms into the low-level tensor axioms (map_reduce, …)
CLowerMapReduce	Lowers the low-level tensor axioms (map_reduce, generate, pad, concat, broadcast) directly to their underlying primitives (loops, extract, insert, pack, …)
CLowerToMem	Bufferizes the low-level tensor axioms onto the shared buffer layer
CReassoc	Reassociates chains of tensor.product_2d with the classic matrix-chain-order dynamic program, so that a chain is evaluated with the least number of vector-lane slots
CSlots	The five parallel per-slot lists of a map_reduce_post input group: element type, rank, shape, access map, and the tensor itself
CSplit	One node of a bracketing: i … j splits after s
CPureRead	A pure re-indexed read: the source tensor, the access map into it (over the read's output coordinates), and the source's element type/rank/shape
CADCE	Aggressive Dead Code Elimination
CAnalysis	Traverses the current World using Rewriter infrastructure while staying in the same world
CAnnex	Holds info about an entity defined within a Plugin (called Annex)
CApp
CArr	A (possibly paramterized) Array
CAxm
CIsANode
CIsA
CBetaRed	Inlines in post-order all Lams that occur exactly once in the program or are trivial forwarders
CBranch	Matches (ff, tt)#cond arg where cond is not a Literal
CCheck
CCleanup	Removes unreachable and dead code by rebuilding the whole World into a new one and swapping them afterwards
CClosedMutPhase	Transitively visits all reachable, closed mutables in the World
CDef	Base class for all Defs
CDefKey	Grants fe::Patricia access to Def::gid_
CDiag	Renders a diagnostic through PlainNames and - if that turned out ambiguous - once more with Def::unique_name
CDispatch	Matches (target_0, target_1, ...)#index arg
CDispatchNormalize	Normalizes Dispatches: η-expands non-Lam targets so that every target of a (t_0, ..., t_n)#index jump table is a Lam, as later phases and the backends expect
CDotConfig	Options for Def::dot, World::dot, and Nest::dot
CDriver	Some "global" variables needed all over the place
CNames
CPaths	An ordered list of directories
CImports
CEntry
CEtaConv	Combined η-normalization: folds η-reduction and η-expansion into a single, idempotent phase
CExt	Common base for TExtremum
CExtract	Extracts from a Sigma or Array-typed Extract::tuple the element at position Extract::index
CFlags	Compiler switches that must be saved and looked up in later phases of compilation
CGIDHash
CGIDLt
CHole	This node is a hole in the IR that is inferred by its context later on
CIdx	A built-in constant of type Nat -> *
CImporter	Imports from Driver::library: an annex therein is looked up via World::annex, so it is imported only once
CInj	Constructs a Join or Variant value
CInsert	Creates a new Tuple / Pack by inserting Insert::value at position Insert::index into Insert::tuple
CJoin	A union type whose ops are sorted and deduplicated: T ∪ T is T
CLam	A function
CLamSpec	Specializes a Lam at its call site by inlining all Pi-typed (i.e. higher-order) arguments
CLevel
CLit
CLMax
CLSucc
CMatch	Scrutinize Match::scrutinee() and dispatch to Match::arms
CName	Nominal newtype term introduction
CNat
CNest	Builds a nesting tree for all mutables/binders
CNode
CChildren
CSiblDeps
CNestPhase	Like ClosedMutPhase but computes a Nest for each NestPhase::visit
CNom	Nominal newtype formation
CNomErasure	Eliminates all nominal newtypes, so that no Nom/Name/Struc ever reaches a backend
COut	A file name from the command line and the stream to write to;
CPack	A (possibly paramterized) Tuple
CPhase	A Phase performs one self-contained task over the whole World
CPhaseMan	Organizes several Phases into a pipeline
CPi	A dependent function type
CPlainNames	Renders Defs with their plain Def::sym instead of Def::unique_name while alive
CPlugin	Basic info and registration function pointer to be returned from a specific plugin
CPluginArg	One -X <plugin>:<arg> a Plugin understands; see Arguments
CPluginEnv	One environment variable a Plugin reads; see Environment Variables
CPluginSym	One symbol a Plugin offers to other Plugins; see Driver::get_fun_ptr
CProd	Base class for Sigma and Tuple
CProxy	Used as intermediate value during optimizatinos such as Analysis
CReform	Type formation of a rewrite Rule
CRepl	An RWPhase that searches for a pattern and replaces it
CRetWrap
CRewriter	Recurseivly rebuilds part of a program into the provided World w.r.t. Rewriter::map
CScope
CRule	A rewrite rule
CRWPhase	Rebuilds old_world() into new_world() and then swaps them
CScalarize	Scalarization (= argument simplification):
CSCCP	SCCP - Sparse Conditional Constant Propagation - but propagates arbitrary expressions
CScheduler
CSelect	Matches (ff, tt)#cond - where cond is a Bool but not a Literal
CSeq	Base class for Arr and Pack
CSetters	CRTP-based mixin to declare setters for Def::loc & Def::name using a covariant return type
CShape	The extents of a Seq's axes: a plain Nat for a single axis, an aggregate of them for several
CSieve	Filters the components of an aggregate and keeps track of where the survivors end up
CSigma	A dependent tuple type
CSingle	Singleton type formation
CSingleErasure	Eliminates all types that have exactly one inhabitant, so that no Single/Wrap ever reaches a backend
CStaticArgOpt	Static Argument Transformation
CStruc	Nominal newtype term elimination
CSwitch	Matches a jump table (target_0, target_1, ...)#index where index is a non-Literal Idx n and n the arity
CTExt	Extremum. Either Top (Up) or Bottom
CTuple	Data constructor for a Sigma
CType
CUse	Const Def*erences a user
CUseEq
CUseHash
CVar	A variable introduced by a binder (mutable)
CVariant	A sum type whose cases are positional: unlike a Join, they are neither sorted nor deduplicated
CVarRewriter	Extends Rewriter for variable substitution
CVersion
CWorld	The World represents the whole program and manages creation of MimIR nodes (Defs)
CCurrLoc	World::get_loc together with its interned DbgKey, so pushing/popping a Loc never re-interns it
CState
CPOD	Plain Old Data
CExternals
CAnnexes
CEntry
CWrap	Singleton term introduction
CZonker
CNamed	Phase hook for compile.named