# Generated by tools/gen_tags.nim from doc/tags.md. DO NOT EDIT!

import tags

type
  NiflerKind* = enum
    None
    ErrL = (ord(ErrTagId), "err")  ## indicates an error
    SufL = (ord(SufTagId), "suf")  ## literal with suffix annotation
    AtL = (ord(AtTagId), "at")  ## array indexing operation (typed Nimony form vs untyped NIFC form); also used for generic proc/type instantiation `(at callee T1 T2 ...)`
    DerefL = (ord(DerefTagId), "deref")  ## pointer deref operation
    DotL = (ord(DotTagId), "dot")  ## object field selection; optional integer is the inheritance depth of the field; optional trailing `STRLIT` is an *access token* (carrying `"x"` like an export marker) — when present, the expression was already type-checked in a scope with access to the field, so re-check at expansion/serialization sites must accept the access even if the field is private. Emitted by sem when a template body or `.semantics` serializer is type-checked in the field's defining module and later expanded/consumed elsewhere.
    ParL = (ord(ParTagId), "par")  ## syntactic parenthesis
    AddrL = (ord(AddrTagId), "addr")  ## address of operation
    NilL = (ord(NilTagId), "nil")  ## nil pointer value; closure `nil` carries the proc type and a nil environment
    OconstrL = (ord(OconstrTagId), "oconstr")  ## object constructor
    BracketL = (ord(BracketTagId), "bracket")  ## untyped array constructor
    CurlyL = (ord(CurlyTagId), "curly")  ## untyped set constructor
    CurlyatL = (ord(CurlyatTagId), "curlyat")  ## curly expression `a{i}`
    KvL = (ord(KvTagId), "kv")  ## key-value pair; optional INTLIT indicates field is in an inherited object
    VvL = (ord(VvTagId), "vv")  ## value-value pair (used for explicitly named arguments in function calls)
    CastL = (ord(CastTagId), "cast")  ## `cast` operation (typed cast expression, or `{.cast(pragma).}` pragma form)
    CallL = (ord(CallTagId), "call")  ## call operation
    CmdL = (ord(CmdTagId), "cmd")  ## command operation
    RangesL = (ord(RangesTagId), "ranges")
    VarL = (ord(VarTagId), "var")  ## variable declaration; type slot may be omitted when inferred from initializer
    ParamL = (ord(ParamTagId), "param")  ## parameter declaration
    ConstL = (ord(ConstTagId), "const")  ## const variable declaration
    LetL = (ord(LetTagId), "let")  ## let variable declaration; type is optional when used in `(unpackflat …)`
    TypevarL = (ord(TypevarTagId), "typevar")  ## type variable declaration; constraint `.T` is optional
    EfldL = (ord(EfldTagId), "efld")  ## enum field declaration; slot 2 carries the export marker *or* the compile-time value (may be `.`)
    FldL = (ord(FldTagId), "fld")  ## field declaration
    ProcL = (ord(ProcTagId), "proc")  ## proc declaration
    FuncL = (ord(FuncTagId), "func")  ## function declaration
    IteratorL = (ord(IteratorTagId), "iterator")  ## iterator declaration
    ConverterL = (ord(ConverterTagId), "converter")  ## converter declaration
    MethodL = (ord(MethodTagId), "method")  ## method declaration
    MacroL = (ord(MacroTagId), "macro")  ## macro declaration
    TemplateL = (ord(TemplateTagId), "template")  ## template declaration
    TypeL = (ord(TypeTagId), "type")  ## type declaration
    BlockL = (ord(BlockTagId), "block")  ## block declaration
    AsgnL = (ord(AsgnTagId), "asgn")  ## assignment statement
    IfL = (ord(IfTagId), "if")  ## if statement header
    WhenL = (ord(WhenTagId), "when")  ## when statement header
    ElifL = (ord(ElifTagId), "elif")  ## pair of (condition, action)
    ElseL = (ord(ElseTagId), "else")  ## `else` action
    TypevarsL = (ord(TypevarsTagId), "typevars")  ## type variable/generic parameters
    BreakL = (ord(BreakTagId), "break")  ## `break` statement
    ContinueL = (ord(ContinueTagId), "continue")  ## `continue` statement
    ForL = (ord(ForTagId), "for")  ## for statement
    WhileL = (ord(WhileTagId), "while")  ## `while` statement
    CaseL = (ord(CaseTagId), "case")  ## `case` statement
    OfL = (ord(OfTagId), "of")  ## `of` branch within a `case` statement
    RetL = (ord(RetTagId), "ret")  ## `return` instruction
    YldL = (ord(YldTagId), "yld")  ## yield statement
    StmtsL = (ord(StmtsTagId), "stmts")  ## list of statements
    ParamsL = (ord(ParamsTagId), "params")  ## list of proc parameters, also used as a "proc type"
    ObjectL = (ord(ObjectTagId), "object")  ## object type declaration
    EnumL = (ord(EnumTagId), "enum")  ## enum type declaration
    ProctypeL = (ord(ProctypeTagId), "proctype")  ## Nimony proc type. Slot 0 carries the nilability tag — either a `.` placeholder or one of `(notnil)`, `(nil)`, `(unchecked)`. NIFC proc type, same shape as `(proc D ...)` with anonymous name slot (varargs spec; effects/body slots present but unused).
    PtrL = (ord(PtrTagId), "ptr")  ## `ptr` type contructor; the `(unchecked)` pragma relaxes nil checking on deref
    PragmasL = (ord(PragmasTagId), "pragmas")  ## begin of pragma section
    PragmaxL = (ord(PragmaxTagId), "pragmax")  ## pragma expressions
    IncludeL = (ord(IncludeTagId), "include")  ## `include` statement
    ImportL = (ord(ImportTagId), "import")  ## `import` statement
    ImportasL = (ord(ImportasTagId), "importas")  ## `import as` statement
    FromimportL = (ord(FromimportTagId), "fromimport")  ## `from import` statement
    ImportexceptL = (ord(ImportexceptTagId), "importexcept")  ## `importexcept` statement
    ExportL = (ord(ExportTagId), "export")  ## `export` statement
    ExportexceptL = (ord(ExportexceptTagId), "exportexcept")  ## `exportexcept` statement
    CommentL = (ord(CommentTagId), "comment")  ## `comment` statement; also used as a variadic trailer for module metadata
    DiscardL = (ord(DiscardTagId), "discard")  ## `discard` statement; optional expression to discard
    TryL = (ord(TryTagId), "try")  ## `try` statement
    RaiseL = (ord(RaiseTagId), "raise")  ## `raise` statement
    StaticL = (ord(StaticTagId), "static")  ## `static` type or annotation
    UnpackflatL = (ord(UnpackflatTagId), "unpackflat")  ## unpack into flat variable list
    UnpacktupL = (ord(UnpacktupTagId), "unpacktup")  ## unpack tuple
    UnpackdeclL = (ord(UnpackdeclTagId), "unpackdecl")  ## unpack var/let/const declaration
    ExceptL = (ord(ExceptTagId), "except")  ## except subsection
    FinL = (ord(FinTagId), "fin")  ## finally subsection
    TupleL = (ord(TupleTagId), "tuple")  ## `tuple` type
    RefL = (ord(RefTagId), "ref")  ## `ref` type; the `(unchecked)` pragma relaxes nil checking on deref
    MutL = (ord(MutTagId), "mut")  ## `mut` type
    OutL = (ord(OutTagId), "out")  ## `out` type
    ConceptL = (ord(ConceptTagId), "concept")  ## `concept` type: two reserved slots, a typevar symbol and the concept body statements
    DistinctL = (ord(DistinctTagId), "distinct")  ## `distinct` type
    ItertypeL = (ord(ItertypeTagId), "itertype")  ## `itertype` type
    QuotedL = (ord(QuotedTagId), "quoted")  ## name in backticks
    TupL = (ord(TupTagId), "tup")  ## untyped tuple constructor
    TabconstrL = (ord(TabconstrTagId), "tabconstr")  ## table constructor
    CallstrlitL = (ord(CallstrlitTagId), "callstrlit")
    InfixL = (ord(InfixTagId), "infix")  ## infix call form kept verbatim inside unsem'd bodies: operator followed by two or more operands (extra args come from default parameters, e.g. `s $ 80` → `` `$`(s, 80, defaultReplacement) ``)
    PrefixL = (ord(PrefixTagId), "prefix")  ## prefix call form kept verbatim inside unsem'd bodies: operator followed by single operand
    TypeofL = (ord(TypeofTagId), "typeof")  ## `typeof` operation for accessing the type of an expression
    ExprL = (ord(ExprTagId), "expr")
    DoL = (ord(DoTagId), "do")  ## `do` expression
    StaticstmtL = (ord(StaticstmtTagId), "staticstmt")  ## `static` statement
    BindL = (ord(BindTagId), "bind")  ## `bind` statement
    MixinL = (ord(MixinTagId), "mixin")  ## `mixin` statement
    UsingL = (ord(UsingTagId), "using")  ## `using` statement
    AsmL = (ord(AsmTagId), "asm")  ## `asm` statement
    DeferL = (ord(DeferTagId), "defer")  ## `defer` statement
