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
CFiles
CAxmDecl	axm dbg: type, normalizer, curry, trip;
CSibling	A further tag sharing AxmDecl::type/normalizer/curry/trip with the AxmDecl that owns them
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
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 of a group dbg_0 ... dbg_n-1: type that refers to the trailing IdPtrn::id
CHoleExpr	?
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 of a MatchExpr
CModDecl	mod dbg { decls }; also the base of the anonymous File
CMods	Raw, unvalidated combination of priv/pub/extern/anx modifiers written before a declaration
CNode	Base class of all AST nodes
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
CPrimaryExpr	tag
CPtrn	Base class of all patterns
CR
CRecDecl	rec dbg = body; with an optional and RecDecl::next
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
CSeqExpr	«arity; body» or ‹arity; body› if SeqExpr::is_pack
CSigmaExpr	Wraps a TuplePtrn as Expr
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
CUniqExpr	⦃inhabitant⦄
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
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
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 clos.attr markers (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.attr.esc or clos.attr.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
Nll	The ll Plugin
CBB
CEmit	Pipeline phase for ll.emit
CEmitter
Nll_nvptx	The ll_nvptx Plugin
CDeviceEmitFlags
CDeviceEmitter
CEmit
CHostEmitter
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
CSEO	Symbolic Expression Optimization
Nregex	The regex Plugin
Capp_range
CLowerRegex	Lowers a regex axm application to a DFA matcher function
Ntensor	The tensor Plugin
Nphase
CFuse
CLower	Lowers the high-level tensor axioms into the low-level tensor axioms (map_reduce, …)
CLowerGetSet	Lowers the tensor axioms (get, set) to their underlying primitives (extract, insert)
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
Nsexpr
CBB
CEmitter
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
CBound	Common base for TBound
CBranch	Matches (ff, tt)#cond arg where cond is not a Literal
CBranchNormalize	Normalizes branches: η-expands non-Lam branch targets so that both sides of a (f, t)#cond branch are Lams, as later phases and the backends expect
CChecker
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 a dispatch through a jump table of the form: (target_0, target_1, ...)#index arg where index is not a Literal
CDotConfig	Options for Def::dot and World::dot
CDriver	Some "global" variables needed all over the place
CNames
CPaths	An ordered list of directories
CImports
CEntry
CEmitter
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
CGlobal
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 -> *
CInj	Constructs a Join value
CInplaceRWPhase	Rewrites the current World in place - unlike an RWPhase, which rebuilds a new World
CInsert	Creates a new Tuple / Pack by inserting Insert::value at position Insert::index into Insert::tuple
CLam	A function
CLamSpec	Specializes a Lam at its call site by inlining all Pi-typed (i.e. higher-order) arguments
CLit
CMatch	Scrutinize Match::scrutinee() and dispatch to Match::arms
CMerge	Constructs a Meet value
CNat
CNest	Builds a nesting tree for all mutables/binders
CNode
CChildren
CSiblDeps
CNestPhase	Like ClosedMutPhase but computes a Nest for each NestPhase::visit
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
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
CRule	A rewrite rule
CRWBase	Common base of the two rewriting Phases: RWPhase rebuilds the World, InplaceRWPhase stays in it
CRWPhase	Rebuilds old_world() into new_world() and then swaps them
CScalarize	Perform Scalarization (= Argument simplification)
CScheduler
CSelect	Matches (ff, tt)#cond - where cond is 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
CSigma	A dependent tuple type
CSplit	Picks the aspect of a Meet [value](Pick::value) by its [type](Def::type)
CStaticArgOpt	Static Argument Transformation
CTBound	Specific Bound depending on Up
CTExt	Extremum. Either Top (Up) or Bottom
CTuple	Data constructor for a Sigma
CType
CUInc
CUMax
CUniq	A singleton wraps a type into a higher order type
CUniv
CUnload
CUse	Const Def*erences a user
CUseEq
CUseHash
CVar	A variable introduced by a binder (mutable)
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
CZonker
CNamed	Phase hook for compile.named