From 82d3e5e4080af541485d6cdd08a1b11322cfd199 Mon Sep 17 00:00:00 2001 From: Jost Berthold Date: Mon, 26 Aug 2024 21:02:10 +1000 Subject: [PATCH] Add annotations and tweaks to parse a complete smir json (#408) * read a file in convert-from-definition instead of expecting verbatim json * add more file requires clauses to reflect imports As it turns out, these `requires "my-file.k"` clauses are interpreted _transitively_, but we should add all requirements explicitly to make editing and moving module contents easier. * WIP annotating K productions for parsing, top-down * WIP fixing var-debug-info parsing * teach the parser some more English plurals * fix parser for var_debug_info from panic_example * mir group annotations for all syntax in ty.k * reformat body.k to remove overly long lines * accept strings as single arguments of enum variants * Fix symbol typo, simplify Ty syntax, rename GenericArg * The `Ty` production with a struct was not observed in the wild yet. In addition, the [related rust code](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.Ty.html) seems to not have the modeled structure. * The `GenericArgs` list needs to contain elements of sort `GenericArg`, not `GenericArgKind` (see python list parsing code). * fix MonoItems parsing * Fix `GlobalAllocs` parsing (renamed from `GlobalAllocMap`) * add some details to the parser documentation notes * Set Version: 0.3.38 * Set Version: 0.3.39 * From review: add/correct list symbols as per convention, remove some comments, remove unused `Ty` production --------- Co-authored-by: devops --- kmir/pyproject.toml | 2 +- kmir/src/kmir/__init__.py | 2 +- .../kmir/convert_from_definition/__main__.py | 4 +- .../src/kmir/convert_from_definition/notes.md | 19 +- .../kmir/convert_from_definition/v2parser.py | 24 +- kmir/src/kmir/kdist/mir-semantics/abi.md | 6 +- kmir/src/kmir/kdist/mir-semantics/alloc.md | 34 +- kmir/src/kmir/kdist/mir-semantics/body.md | 172 ++++-- kmir/src/kmir/kdist/mir-semantics/kmir-ast.md | 2 +- kmir/src/kmir/kdist/mir-semantics/lib.md | 7 +- kmir/src/kmir/kdist/mir-semantics/mono.md | 37 +- kmir/src/kmir/kdist/mir-semantics/ty.md | 563 ++++++++++-------- package/version | 2 +- 13 files changed, 535 insertions(+), 339 deletions(-) diff --git a/kmir/pyproject.toml b/kmir/pyproject.toml index a14906759..9b9781e76 100644 --- a/kmir/pyproject.toml +++ b/kmir/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api" [tool.poetry] name = "kmir" -version = "0.3.38" +version = "0.3.39" description = "" authors = [ "Runtime Verification, Inc. ", diff --git a/kmir/src/kmir/__init__.py b/kmir/src/kmir/__init__.py index 269c06dc2..f907b5df9 100644 --- a/kmir/src/kmir/__init__.py +++ b/kmir/src/kmir/__init__.py @@ -1,3 +1,3 @@ from typing import Final -VERSION: Final = '0.3.38' +VERSION: Final = '0.3.39' diff --git a/kmir/src/kmir/convert_from_definition/__main__.py b/kmir/src/kmir/convert_from_definition/__main__.py index e6ad94d53..09ab25536 100644 --- a/kmir/src/kmir/convert_from_definition/__main__.py +++ b/kmir/src/kmir/convert_from_definition/__main__.py @@ -19,7 +19,9 @@ def main() -> None: tools = semantics() p = Parser(tools.definition) - result = p.parse_mir_json(json.loads(args.json), args.sort) + with open(args.json, 'r') as f: + json_data = json.load(f) + result = p.parse_mir_json(json_data, args.sort) if result is None: print('Parse error!', file=sys.stderr) sys.exit(1) diff --git a/kmir/src/kmir/convert_from_definition/notes.md b/kmir/src/kmir/convert_from_definition/notes.md index f16f1d2f1..25656509e 100644 --- a/kmir/src/kmir/convert_from_definition/notes.md +++ b/kmir/src/kmir/convert_from_definition/notes.md @@ -27,10 +27,10 @@ json: a boolean value, e.g., `true` #### mir-list ``` -syntax L ::= List {E, ""} [group(mir-list), ...] +syntax Elems ::= List {Elem, ""} [group(mir-list), ...] ``` -json: a homogeneous list, e.g. `[e1, e2, e3, ...]` -Note that all elements of the json list `(e1, e2, e3)` should correspond to syntactic productions for the sort E. +json: a homogeneous list, e.g. `[e1, e2, e3, ...]`, where all elements correspond to syntactic productions for the sort `Elem`. +As per naming convention, the list sort `Elems` (plural) should contain elements of sort `Elem` (singular). Usual plural formation rules (`Body -> Bodies`, `Branch -> Branches`) are respected. #### mir-klist-ElementSort ``` @@ -41,10 +41,16 @@ Note that all elements of the json list `(e1, e2, e3)` should correspond to synt #### mir-enum ``` -syntax MyEnum ::= myEnumField1(...) [group(mir-enum), ...] - | myEnumField2(...) [group(mir-enum), ...] +syntax MyEnum ::= myEnumCon1(ArgSort) [group(mir-enum) , symbol(MyEnum::Con1)] + | myEnumCon2(Sort1,Sort2) [group(mir-enum) , symbol(MyEnum::Con2)] + | myEnumCon3(field:...) [group(mir-enum---field), symbol(MyEnum::Con3)] + | "myEnumCon4" [group(mir-enum) , symbol(MyEnum::Con4)] ``` -json: a dictionary with a single key-value pair. The key should correspond to one of the productions for the `MyEnum` Sort, and the value should be valid json. +json: a dictionary with a single key-value pair. +The key should correspond to (symbol for) one of the productions for the `MyEnum` Sort, and the value should be valid json. +Arguments for variants that do not use field names are encoded as (heterogenous) _lists_ in json. +Field names can be added after `mir-enum`, separated by `---`. +Enum variants without arguments are encoded as _json strings_. #### mir-option ``` @@ -63,6 +69,7 @@ syntax MaybeInt::= someInt(Int) [group(mir-option-int)] #### mir Any remaining production describing MIR syntax. + ### Conventions for productions - Syntax productions with more than one non terminals should not include sorts `Int`, `Bool`, `String`, but should instead use the sorts `MIRInt`, `MIRBool`, `MIRString`. These are intended to be semantically equivalent, i.e. ``` diff --git a/kmir/src/kmir/convert_from_definition/v2parser.py b/kmir/src/kmir/convert_from_definition/v2parser.py index 6afb91b2c..f71b47f55 100644 --- a/kmir/src/kmir/convert_from_definition/v2parser.py +++ b/kmir/src/kmir/convert_from_definition/v2parser.py @@ -99,14 +99,19 @@ def _list_symbols(sort: str) -> tuple[str, str]: # Given a list Sort, return the element sort. def _element_sort(sort: KSort) -> KSort: name = sort.name - # Dictionary containing irregular plural to singular sort names. - element_name = { - 'Bodies': 'Body', - 'Branches': 'Branch', - 'VariantAndFieldIndices': 'VariantAndFieldIndex', - }.get(name) - if element_name: - return KSort(element_name) + if name.endswith('ies'): # Bodies, Entries, ... + return KSort(name[:-3] + 'y') + elif ( # -es for words ending in 's', 'ch', 'sh', 'ss', 'x' or 'z' + name.endswith('ses') + or name.endswith('ches') + or name.endswith('shes') + or name.endswith('sses') + or name.endswith('xes') + or name.endswith('zes') + ): + return KSort(name[:-2]) + elif name.endswith('Indices'): + return KSort(name[:-7] + 'Index') # If the name is not lsted above, we assume it has a regular plural form. # Simply remove trailing 's' to get the singular for element sort name. assert name.endswith('s') @@ -261,7 +266,8 @@ def _parse_mir_enum_json(self, json: JSON, sort: KSort) -> ParseResult: # case, the argument needs to be changed to a list, so that its # structure is not cosidered a part of the current enumeration. if not _has_named_fields(_get_group(prod)) and len(prod.argument_sorts) == 1: - assert not isinstance(json_value, Sequence) + # str is a Sequence, therefore the extra check + assert isinstance(json_value, str) or not isinstance(json_value, Sequence) json_value = [json_value] return self._parse_mir_nonterminal_json(json_value, prod) else: diff --git a/kmir/src/kmir/kdist/mir-semantics/abi.md b/kmir/src/kmir/kdist/mir-semantics/abi.md index 509a83063..111d01669 100644 --- a/kmir/src/kmir/kdist/mir-semantics/abi.md +++ b/kmir/src/kmir/kdist/mir-semantics/abi.md @@ -1,4 +1,8 @@ ```k +requires "lib.md" +requires "target.md" +requires "ty.md" + module ABI imports LIB-SORTS imports TARGET-SORTS @@ -143,4 +147,4 @@ syntax CallConvention ::= "callConventionC" | "callConventionRiscvInterrupt" endmodule -``` \ No newline at end of file +``` diff --git a/kmir/src/kmir/kdist/mir-semantics/alloc.md b/kmir/src/kmir/kdist/mir-semantics/alloc.md index a23a7359a..8d412d6b5 100644 --- a/kmir/src/kmir/kdist/mir-semantics/alloc.md +++ b/kmir/src/kmir/kdist/mir-semantics/alloc.md @@ -1,4 +1,7 @@ ```k +requires "ty.md" +requires "mono.md" + module ALLOC-SORTS syntax AllocId @@ -27,16 +30,27 @@ module ALLOC ```k syntax BinderForExistentialTraitRef ::= binderForExistentialTraitRef(value: ExistentialTraitRef, boundVars: BoundVariableKindList) -syntax MaybeBinderForExistentialTraitRef ::= someBinderForExistentialTraitRef(BinderForExistentialTraitRef) - | "noBinderForExistentialTraitRef" -syntax GlobalAlloc ::= globalAllocFunction(Instance) - | globalAllocVTable(Ty, MaybeBinderForExistentialTraitRef) - | globalAllocStatic(StaticDef) [symbol(globalAllocStatic)] - | globalAllocMemory(Allocation) [symbol(globalAllocMemory)] - -syntax GlobalAllocEntry ::= globalAllocEntry(MIRInt, GlobalAlloc) [symbol(globalAllocEntry)] -syntax GlobalAllocsMap ::= List {GlobalAllocEntry, ""} [symbol(globalAllocsMap), terminator-symbol(.globalAllocsMap)] + [group(mir---value--bound-vars)] + +syntax MaybeBinderForExistentialTraitRef ::= someBinderForExistentialTraitRef(BinderForExistentialTraitRef) [group(mir-option)] + | "noBinderForExistentialTraitRef" [group(mir-option)] + +syntax GlobalAllocKind ::= globalAllocFunction(Instance) + [group(mir-enum), symbol(GlobalAllocKind::Function)] + | globalAllocVTable(Ty, MaybeBinderForExistentialTraitRef) + [group(mir-enum), symbol(GlobalAllocKind::VTable)] + | Static(StaticDef) + [group(mir-enum), symbol(GlobalAllocKind::Static)] + | Memory(Allocation) + [group(mir-enum), symbol(GlobalAllocKind::Memory)] + +syntax GlobalAlloc ::= globalAllocEntry(MIRInt, GlobalAllocKind) + [symbol(globalAllocEntry), group(mir)] + +syntax GlobalAllocs ::= List {GlobalAlloc, ""} + [symbol(GlobalAllocs::append), terminator-symbol(GlobalAllocs::empty), group(mir-list)] + syntax AllocId ::= allocId(Int) [symbol(allocId)] endmodule -``` \ No newline at end of file +``` diff --git a/kmir/src/kmir/kdist/mir-semantics/body.md b/kmir/src/kmir/kdist/mir-semantics/body.md index c9e6ab72f..655ba31e9 100644 --- a/kmir/src/kmir/kdist/mir-semantics/body.md +++ b/kmir/src/kmir/kdist/mir-semantics/body.md @@ -1,4 +1,7 @@ ```k +requires "lib.md" +requires "ty.md" + module BODY-SORTS syntax Body @@ -30,7 +33,7 @@ module BODY - BasicBlockIdx - not present - [Operand](https://github.com/runtimeverification/rust/blob/85f90a461262f7ca37a6e629933d455fa9c3ee48/compiler/rustc_middle/src/mir/syntax.rs#L1155-L1200) - [Local](https://github.com/runtimeverification/rust/blob/85f90a461262f7ca37a6e629933d455fa9c3ee48/compiler/rustc_middle/src/mir/mod.rs#L901-L909) -- [ProjectionElem](https://github.com/runtimeverification/rust/blob/85f90a461262f7ca37a6e629933d455fa9c3ee48/compiler/rustc_middle/src/mir/syntax.rs#L1065-L1148) [PlaceElem](https://github.com/runtimeverification/rust/blob/85f90a461262f7ca37a6e629933d455fa9c3ee48/compiler/rustc_middle/src/mir/syntax.rs#L1150-L1152) +- [ProjectionElem](https://github.com/runtimeverification/rust/blob/85f90a461262f7ca37a6e629933d455fa9c3ee48/compiler/rustc_middle/src/mir/syntax.rs#L1065-L1148) [PlaceElem](https://github.com/runtimeverification/rust/blob/85f90a461262f7ca37a6e629933d455fa9c3ee48/compiler/rustc_middle/src/mir/syntax.rs#L1150-L1152) - [Place](https://github.com/runtimeverification/rust/blob/85f90a461262f7ca37a6e629933d455fa9c3ee48/compiler/rustc_middle/src/mir/syntax.rs#L979-L1063) - [SwitchTargets](https://github.com/runtimeverification/rust/blob/85f90a461262f7ca37a6e629933d455fa9c3ee48/compiler/rustc_middle/src/mir/syntax.rs#L877-L896) @@ -170,7 +173,7 @@ syntax PointerCoercion ::= "pointerCoercionReifyFnPointer" [group(mir-e syntax CastKind ::= "castKindPointerExposeAddress" [group(mir-enum), symbol(CastKind::ExposeAddress)] | "castKindPointerWithExposedProvenance" [group(mir-enum), symbol(CastKind::PointerWithExposedProvenance)] - | castKindPointerCoercion(PointerCoercion) [group(mir-enum), symbol(CastKind::PointerCoercision)] + | castKindPointerCoercion(PointerCoercion) [group(mir-enum), symbol(CastKind::PointerCoercion)] | "castKindDynStar" [group(mir-enum), symbol(CastKind::DynStar)] | "castKindIntToInt" [group(mir-enum), symbol(CastKind::IntToInt)] | "castKindFloatToInt" [group(mir-enum), symbol(CastKind::FloatToInt)] @@ -206,6 +209,7 @@ syntax AggregateKind ::= aggregateKindArray(Ty) | aggregateKindCoroutine(CoroutineDef, GenericArgs, Movability) [group(mir-enum), symbol(AggregateKind::Coroutine)] | aggregateKindRawPtr(Ty, Mutability) [group(mir-enum), symbol(AggregateKind::RawPtr)] + // FIXME the arguments for some of these are _heterogenous lists_ in smir_pretty syntax Rvalue ::= rvalueAddressOf(Mutability, Place) [group(mir-enum), symbol(Rvalue::AddressOf)] | rvalueAggregate(AggregateKind, Operands) [group(mir-enum), symbol(Rvalue::Aggregate)] | rvalueBinaryOp(BinOp, Operand, Operand) [group(mir-enum), symbol(Rvalue::BinaryOp)] @@ -227,19 +231,55 @@ syntax Rvalue ::= rvalueAddressOf(Mutability, Place) [group( /////// Statements -syntax StatementKind ::= statementKindAssign(place: Place, rvalue: Rvalue) [group(mir-enum), symbol(StatementKind::Assign)] - | statementKindFakeRead(cause: FakeReadCause, place: Place) [group(mir-enum), symbol(StatementKind::FakeRead)] - | statementKindSetDiscriminant(place: Place, variantIndex: VariantIdx) [group(mir-enum---place--variant-index), symbol(StatementKind::SetDiscriminant)] - | deinit(place: Place) [group(mir-enum), symbol(StatementKind::Deinit)] - | statementKindStorageLive(Local) [group(mir-enum), symbol(StatementKind::StorageLive)] - | statementKindStorageDead(Local) [group(mir-enum), symbol(StatementKind::StorageDead)] - | statementKindRetag(kind: RetagKind, place: Place) [group(mir-enum), symbol(StatementKind::Retag)] - | statementKindPlaceMention(place: Place) [group(mir-enum), symbol(StatementKind::PlaceMention)] +syntax StatementKind ::= statementKindAssign(place: Place, rvalue: Rvalue) + [ group(mir-enum) + , symbol(StatementKind::Assign) + ] + | statementKindFakeRead(cause: FakeReadCause, place: Place) + [ group(mir-enum) + , symbol(StatementKind::FakeRead) + ] + | statementKindSetDiscriminant(place: Place, variantIndex: VariantIdx) + [ group(mir-enum---place--variant-index) + , symbol(StatementKind::SetDiscriminant) + ] + | deinit(place: Place) + [ group(mir-enum) + , symbol(StatementKind::Deinit) + ] + | statementKindStorageLive(Local) + [ group(mir-enum) + , symbol(StatementKind::StorageLive) + ] + | statementKindStorageDead(Local) + [ group(mir-enum) + , symbol(StatementKind::StorageDead) + ] + | statementKindRetag(kind: RetagKind, place: Place) + [ group(mir-enum) + , symbol(StatementKind::Retag) + ] + | statementKindPlaceMention(place: Place) + [ group(mir-enum) + , symbol(StatementKind::PlaceMention) + ] | statementKindAscribeUserType(place: Place, projections: UserTypeProjection, variance: Variance) [group(mir-enum---place--projections--variance), symbol(StatementKind::AscribeUserType)] - | statementKindCoverage(Coverage) [group(mir-enum), symbol(StatementKind::Coverage)] - | statementKindIntrinsic(NonDivergingIntrinsic) [group(mir-enum), symbol(StatementKind::Intrinsic)] - | "statementKindConstEvalCounter" [group(mir-enum), symbol(StatementKind::ConstEvalCounter)] - | "statementKindNop" [group(mir-enum), symbol(StatementKind::Nop)] + | statementKindCoverage(Coverage) + [ group(mir-enum) + , symbol(StatementKind::Coverage) + ] + | statementKindIntrinsic(NonDivergingIntrinsic) + [ group(mir-enum) + , symbol(StatementKind::Intrinsic) + ] + | "statementKindConstEvalCounter" + [ group(mir-enum) + , symbol(StatementKind::ConstEvalCounter) + ] + | "statementKindNop" + [ group(mir-enum) + , symbol(StatementKind::Nop) + ] syntax Statement ::= statement(kind: StatementKind, span: Span) [group(mir---kind--span)] syntax Statements ::= List {Statement, ""} [group(mir-list), symbol(Statements::append), terminator-symbol(Statements::empty)] @@ -247,28 +287,65 @@ syntax Statements ::= List {Statement, ""} [group(mir-list), symbol(Statements:: /////// Terminators -syntax AssertMessage ::= assertMessageBoundsCheck(len: Operand, index: Operand) [group(mir-enum---len--index), symbol(AssertMessage::BoundsCheck)] - | assertMessageOverflow(BinOp, Operand, Operand) [group(mir-enum), symbol(AssertMessage::Overflow)] - | assertMessageOverflowNeg(Operand) [group(mir-enum), symbol(AssertMessage::OverflowNeg)] - | assertMessageDivisionByZero(Operand) [group(mir-enum), symbol(AssertMessage::DivisionByZero)] - | assertMessageRemainderByZero(Operand) [group(mir-enum), symbol(AssertMessage::RemainderByZero)] - | assertMessageResumedAfterReturn(CoroutineKind) [group(mir-enum), symbol(AssertMessage::ResumedAfterReturn)] - | assertMessageResumedAfterPanic(CoroutineKind) [group(mir-enum), symbol(AssertMessage::ResumedAfterPanic)] - | assertMessageMisalignedPointerDereference(required: Operand, found: Operand) [group(mir-enum---required--found), symbol(AssertMessage::MisalignedPointerDerefence)] - -syntax InlineAsmOperand ::= inlineAsmOperand(inValue: MaybeOperand, outValue: MaybePlace, rawPtr: MIRString) [group(mir---in-value--out-place--raw-rpr)] -syntax InlineAsmOperands ::= List {InlineAsmOperand, ""} [group(mir-list), symbol(InlineAsmOperands::append), terminator-symbol(InlineAsmOperands::empty)] - -syntax TerminatorKind ::= terminatorKindGoto(target: BasicBlockIdx) [group(mir-enum---target), symbol(TerminatorKind::Goto)] +syntax AssertMessage ::= assertMessageBoundsCheck(len: Operand, index: Operand) + [group(mir-enum---len--index), symbol(AssertMessage::BoundsCheck)] + | assertMessageOverflow(BinOp, Operand, Operand) + [group(mir-enum), symbol(AssertMessage::Overflow)] + | assertMessageOverflowNeg(Operand) + [group(mir-enum), symbol(AssertMessage::OverflowNeg)] + | assertMessageDivisionByZero(Operand) + [group(mir-enum), symbol(AssertMessage::DivisionByZero)] + | assertMessageRemainderByZero(Operand) + [group(mir-enum), symbol(AssertMessage::RemainderByZero)] + | assertMessageResumedAfterReturn(CoroutineKind) + [group(mir-enum), symbol(AssertMessage::ResumedAfterReturn)] + | assertMessageResumedAfterPanic(CoroutineKind) + [group(mir-enum), symbol(AssertMessage::ResumedAfterPanic)] + | assertMessageMisalignedPointerDereference(required: Operand, found: Operand) + [group(mir-enum---required--found), symbol(AssertMessage::MisalignedPointerDerefence)] + +syntax InlineAsmOperand ::= inlineAsmOperand(inValue: MaybeOperand, outValue: MaybePlace, rawPtr: MIRString) + [group(mir---in-value--out-place--raw-rpr)] +syntax InlineAsmOperands ::= List {InlineAsmOperand, ""} + [group(mir-list), symbol(InlineAsmOperands::append), terminator-symbol(InlineAsmOperands::empty)] + +syntax TerminatorKind ::= terminatorKindGoto(target: BasicBlockIdx) + [ group(mir-enum---target) + , symbol(TerminatorKind::Goto) + ] | terminatorKindSwitchInt(discr: Operand, targets: SwitchTargets) [group(mir-enum---discr--targets), symbol(TerminatorKind::SwitchInt)] - | "terminatorKindResume" [group(mir-enum), symbol(TerminatorKind::Resume)] - | "terminatorKindAbort" [group(mir-enum), symbol(TerminatorKind::Abort)] - | "terminatorKindReturn" [group(mir-enum), symbol(TerminatorKind::Return)] - | "terminatorKindUnreachable" [group(mir-enum), symbol(TerminatorKind::Unreachable)] - | terminatorKindDrop(place: Place, target: BasicBlockIdx, unwind: UnwindAction) [group(mir-enum---place--target--unwind), symbol(TerminatorKind::Drop)] - | terminatorKindCall( func: Operand, args: Operands, destination: Place, target: MaybeBasicBlockIdx, unwind: UnwindAction) [group(mir-enum---func--args--destination--target--unwind), symbol(TerminatorKind::Call)] - | assert(cond: Operand, expected: MIRBool, msg: AssertMessage, target: BasicBlockIdx, unwind: UnwindAction) [group(mir-enum---cond--expected--msg--target--unwind), symbol(TerminatorKind::Assert)] - | terminatorKindInlineAsm(template: MIRString, operands: InlineAsmOperands, options: MIRString, lineSpans: MIRString, destination: MaybeBasicBlockIdx, unwind: UnwindAction) [group(mir-enum---template--operands--options--line-spans--destination--unwind), symbol(TerminatorKind::InlineAsm)] + | "terminatorKindResume" + [ group(mir-enum) + , symbol(TerminatorKind::Resume) + ] + | "terminatorKindAbort" + [ group(mir-enum) + , symbol(TerminatorKind::Abort) + ] + | "terminatorKindReturn" + [ group(mir-enum) + , symbol(TerminatorKind::Return) + ] + | "terminatorKindUnreachable" + [ group(mir-enum) + , symbol(TerminatorKind::Unreachable) + ] + | terminatorKindDrop(place: Place, target: BasicBlockIdx, unwind: UnwindAction) + [ group(mir-enum---place--target--unwind) + , symbol(TerminatorKind::Drop) + ] + | terminatorKindCall( func: Operand, args: Operands, destination: Place, target: MaybeBasicBlockIdx, unwind: UnwindAction) + [ group(mir-enum---func--args--destination--target--unwind) + , symbol(TerminatorKind::Call) + ] + | assert(cond: Operand, expected: MIRBool, msg: AssertMessage, target: BasicBlockIdx, unwind: UnwindAction) + [ group(mir-enum---cond--expected--msg--target--unwind) + , symbol(TerminatorKind::Assert) + ] + | terminatorKindInlineAsm(template: MIRString, operands: InlineAsmOperands, options: MIRString, lineSpans: MIRString, destination: MaybeBasicBlockIdx, unwind: UnwindAction) + [ group(mir-enum---template--operands--options--line-spans--destination--unwind) + , symbol(TerminatorKind::InlineAsm) + ] syntax Terminator ::= terminator(kind: TerminatorKind, span: Span) [group(mir---kind--span)] @@ -288,9 +365,12 @@ syntax Variance ::= "varianceCovariant" [group(mir-enum), symbol(Variance::C | "varianceContravariant" [group(mir-enum), symbol(Variance::Contravariant)] | "varianceBivariant" [group(mir-enum), symbol(Variance::Bivariant)] -syntax CopyNonOverlapping ::= copyNonOverlapping(src: Operand, dst: Operand, count: Operand) [group(mir---src--dst--count)] -syntax NonDivergingIntrinsic ::= nonDivergingIntrinsicAssume(Operand) [group(mir-enum), symbol(NonDivergingIntrinsic::Assume)] - | nonDivergingIntrinsicCopyNonOverlapping(CopyNonOverlapping) [group(mir-enum), symbol(NonDivergingIntrinsic::CopyNonOverlapping)] +syntax CopyNonOverlapping ::= copyNonOverlapping(src: Operand, dst: Operand, count: Operand) + [group(mir---src--dst--count)] +syntax NonDivergingIntrinsic ::= nonDivergingIntrinsicAssume(Operand) + [group(mir-enum), symbol(NonDivergingIntrinsic::Assume)] + | nonDivergingIntrinsicCopyNonOverlapping(CopyNonOverlapping) + [group(mir-enum), symbol(NonDivergingIntrinsic::CopyNonOverlapping)] /////// End terminators @@ -310,14 +390,18 @@ syntax ConstOperand ::= constOperand(span: Span, userTy: MaybeUserTypeAnnotation syntax VarDebugInfoContents ::= varDebugInfoContentsPlace(Place) [group(mir-enum), symbol(VarDebugInfoContents::Place)] | varDebugInfoContentsConst(ConstOperand) [group(mir-enum), symbol(VarDebugInfoContents::Const)] -syntax MaybeInt ::= someInt(Int) [group(mir-option)] +syntax MaybeInt ::= someInt(Int) [group(mir-option-int)] | "noInt" [group(mir-option)] -syntax VarDebugInfo ::= varDebugInfo(name: Symbol, sourceInfo: SourceInfo, composite: MaybeVarDebugInfoFragment, value: VarDebugInfoContents, argumentIndex: MaybeInt) [group(mir---name--source-info--composite--value--argument-index)] -syntax VarDebugInfos ::= List {VarDebugInfo, ""} [group(mir-list), symbol(VarDebugInfos::append), terminator-symbol(VarDebugInfos::empty)] +syntax VarDebugInfo ::= varDebugInfo(name: Symbol, sourceInfo: SourceInfo, composite: MaybeVarDebugInfoFragment, value: VarDebugInfoContents, argumentIndex: MaybeInt) + [group(mir---name--source-info--composite--value--argument-index)] +syntax VarDebugInfos ::= List {VarDebugInfo, ""} + [group(mir-list), symbol(VarDebugInfos::append), terminator-symbol(VarDebugInfos::empty)] -syntax Body ::= body(blocks: BasicBlocks, locals: LocalDecls, argCount: MIRInt, varDebugInfo: VarDebugInfos, spreadArg: MaybeLocal, span: Span) [group(mir---blocks--locals--arg-count--var-debug-info--spread-arg--span)] -syntax Bodies ::= List {Body, ""} [group(mir-list), symbol(Bodies::append), terminator-symbol(Bodies::empty)] +syntax Body ::= body(blocks: BasicBlocks, locals: LocalDecls, argCount: MIRInt, varDebugInfo: VarDebugInfos, spreadArg: MaybeLocal, span: Span) + [group(mir---blocks--locals--arg-count--var-debug-info--spread-arg--span)] +syntax Bodies ::= List {Body, ""} + [group(mir-list), symbol(Bodies::append), terminator-symbol(Bodies::empty)] endmodule -``` \ No newline at end of file +``` diff --git a/kmir/src/kmir/kdist/mir-semantics/kmir-ast.md b/kmir/src/kmir/kdist/mir-semantics/kmir-ast.md index 2608dada2..75f7359a3 100644 --- a/kmir/src/kmir/kdist/mir-semantics/kmir-ast.md +++ b/kmir/src/kmir/kdist/mir-semantics/kmir-ast.md @@ -16,7 +16,7 @@ module KMIR-AST imports TARGET imports TYPES - syntax Pgm ::= Symbol GlobalAllocsMap MonoItems [symbol(pgm)] + syntax Pgm ::= Symbol GlobalAllocs MonoItems [symbol(pgm), group(mir---name--allocs--items)] endmodule ``` \ No newline at end of file diff --git a/kmir/src/kmir/kdist/mir-semantics/lib.md b/kmir/src/kmir/kdist/mir-semantics/lib.md index 79fbe6d94..ccc52f55c 100644 --- a/kmir/src/kmir/kdist/mir-semantics/lib.md +++ b/kmir/src/kmir/kdist/mir-semantics/lib.md @@ -1,4 +1,7 @@ ```k +requires "body.md" +requires "ty.md" + module LIB-SORTS syntax CrateItem @@ -14,7 +17,7 @@ module LIB imports TYPES-SORTS imports STRING -syntax Symbol ::= symbol(String) +syntax Symbol ::= symbol(String) [group(mir-string)] syntax Opaque ::= opaque(String) [symbol(opaque)] syntax Filename ::= filename(String) @@ -33,4 +36,4 @@ syntax CtorKind ::= "ctorKindConst" | "ctorKindFn" endmodule -``` \ No newline at end of file +``` diff --git a/kmir/src/kmir/kdist/mir-semantics/mono.md b/kmir/src/kmir/kdist/mir-semantics/mono.md index d7c84a87c..4ed946efd 100644 --- a/kmir/src/kmir/kdist/mir-semantics/mono.md +++ b/kmir/src/kmir/kdist/mir-semantics/mono.md @@ -1,4 +1,8 @@ ```k +requires "body.md" +requires "lib.md" +requires "ty.md" + module MONO-SORTS syntax Instance @@ -13,16 +17,29 @@ module MONO imports TYPES-SORTS imports INT -syntax StaticDef ::= staticDef(Int) // imported from crate +syntax StaticDef ::= staticDef(Int) [group(mir-int)] // imported from crate + +syntax MaybeAllocation ::= someAllocation(Allocation) [group(mir-option)] + | "noAllocation" [group(mir-option)] + +syntax MonoItemKind ::= monoItemFn(name: Symbol, id: DefId, body: Bodies) + [ group(mir-enum---name--id--body) + , symbol(MonoItemKind::MonoItemFn) + ] + | monoItemStatic(name: Symbol, id: DefId, allocation: MaybeAllocation) + [ group(mir-enum---name--id--allocation) + , symbol(MonoItemKind::MonoItemStatic) + ] + | monoItemGlobalAsm(Opaque) + [ group(mir-enum) + , symbol(MonoItemKind::MonoItemGlobalAsm) + ] +syntax MonoItem ::= monoItem(symbolName: Symbol, monoItemKind: MonoItemKind) + [symbol(monoItemWrapper), group(mir---symbol-name--mono-item-kind)] +syntax MonoItems ::= List {MonoItem, ""} + [symbol(monoItems), terminator-symbol(.monoItems), group(mir-list)] -syntax MaybeAllocation ::= someAllocation(Allocation) | "noAllocation" -syntax MonoItem ::= monoItemFn(Instance) // do not use - parser uses the key to generate the other production - | monoItemStatic(StaticDef) // do not use - parser uses the key to generate the other production - | monoItemFn(name: Symbol, defId: DefId, body: Bodies) [symbol(monoItemFn)] - | monoItemStatic(name: Symbol, defId: DefId, allocation: MaybeAllocation) - | monoItemGlobalAsm(Opaque) -syntax MonoItemWrapper ::= monoItemWrapper(symbolName: Symbol, monoItemKind: MonoItem) [symbol(monoItemWrapper)] -syntax MonoItems ::= List {MonoItemWrapper, ""} [symbol(monoItems), terminator-symbol(.monoItems)] +////////////////////////////////////////// unused for parsing? syntax Instance ::= instance(kind: InstanceKind, def: InstanceDef) syntax InstanceKind ::= "instanceKindItem" [symbol(instanceKindItem)] @@ -32,4 +49,4 @@ syntax InstanceKind ::= "instanceKindItem" [symbol(instanceKindItem)] syntax InstanceDef ::= instanceDef(Int) endmodule -``` \ No newline at end of file +``` diff --git a/kmir/src/kmir/kdist/mir-semantics/ty.md b/kmir/src/kmir/kdist/mir-semantics/ty.md index b93f3c157..03b4bde6e 100644 --- a/kmir/src/kmir/kdist/mir-semantics/ty.md +++ b/kmir/src/kmir/kdist/mir-semantics/ty.md @@ -1,4 +1,9 @@ ```k +requires "alloc.md" +requires "body.md" +requires "lib.md" +requires "mono.md" + module TYPES-SORTS syntax AdtDef @@ -47,284 +52,338 @@ syntax MIRString ::= mirString(String) [group(mir-string), symbol(MIRString::Str syntax LineInfo ::= lineInfo(startLine: MIRInt, startCol: MIRInt, endLine: MIRInt, endCol: MIRInt) syntax InitMaskMaterialized ::= List {MIRInt, ""} -syntax AdtDef ::= adtDef(Int) [group(mir-int)] // imported from crate -syntax AliasDef ::= aliasDef(Int) // imported from crate -syntax BrNamedDef ::= brNamedDef(Int) // imported from crate -syntax ClosureDef ::= closureDef(Int) // imported from crate -syntax ConstDef ::= constDef(Int) // imported from crate -syntax CoroutineDef ::= coroutineDef(Int) // imported from crate -syntax CoroutineWitnessDef ::= coroutineWitnessDef(Int) // imported from crate -syntax FnDef ::= fnDef(Int) // imported from crate -syntax ForeignDef ::= foreignDef(Int) // imported from crate -syntax ForeignModuleDef ::= foreignModuleDef(Int) // imported from crate -syntax GenericDef ::= genericDef(Int) // imported from crate -syntax ImplDef ::= implDef(Int) // imported from crate -syntax ParamDef ::= paramDef(Int) // imported from crate -syntax RegionDef ::= regionDef(Int) // imported from crate -syntax TraitDef ::= traitDef(Int) // imported from crate +syntax AdtDef ::= adtDef(Int) [group(mir-int)] // imported from crate +syntax AliasDef ::= aliasDef(Int) [group(mir-int)] // imported from crate +syntax BrNamedDef ::= brNamedDef(Int) [group(mir-int)] // imported from crate +syntax ClosureDef ::= closureDef(Int) [group(mir-int)] // imported from crate +syntax ConstDef ::= constDef(Int) [group(mir-int)] // imported from crate +syntax CoroutineDef ::= coroutineDef(Int) [group(mir-int)] // imported from crate +syntax CoroutineWitnessDef ::= coroutineWitnessDef(Int) [group(mir-int)] // imported from crate +syntax FnDef ::= fnDef(Int) [group(mir-int)] // imported from crate +syntax ForeignDef ::= foreignDef(Int) [group(mir-int)] // imported from crate +syntax ForeignModuleDef ::= foreignModuleDef(Int) [group(mir-int)] // imported from crate +syntax GenericDef ::= genericDef(Int) [group(mir-int)] // imported from crate +syntax ImplDef ::= implDef(Int) [group(mir-int)] // imported from crate +syntax ParamDef ::= paramDef(Int) [group(mir-int)] // imported from crate +syntax RegionDef ::= regionDef(Int) [group(mir-int)] // imported from crate +syntax TraitDef ::= traitDef(Int) [group(mir-int)] // imported from crate syntax VariantIdx ::= variantIdx(Int) [group(mir-int)] syntax DynKind ::= "dynKindDyn" [group(mir-enum), symbol(DynKind::Dyn)] | "dynKindDynStar" [group(mir-enum), symbol(DynKind::DynStar)] -syntax ForeignModule ::= foreignModule(defId: ForeignModuleDef, abi: Abi) [group(mir-def-id-abi)] - -syntax ForeignItemKind ::= foreignItemKindFn() [group("mir-enum"), symbol("ForeignItemKind::Fn")] - | foreignItemKindStatic(StaticDef) [group("mir-enum"), symbol("ForeignItemKind::Static")] - | foreignItemKindType(Ty) [group("mir-enum"), symbol("ForeignItemKind::Type")] - -syntax AdtKind ::= "adtKindEnum" - | "adtKindUnion" - | "adtKindStruct" - -syntax VariantDef ::= variantDef(idx: VariantIdx, adtDef: AdtDef) - -syntax FieldDef ::= fieldDef(def: DefId, name: Symbol) - -syntax GenericArgKind ::= genericArgKindLifetime(Region) - | genericArgKindType(Ty) - | genericArgKindConst(TyConst) -syntax GenericArgs ::= List {GenericArgKind, ""} [group(mir-list), symbol(GenericArgs::append), terminator-symbol(GenericArgs::empty)] - -syntax TermKind ::= termKindType(Ty) - | termKindConst(TyConst) - -syntax AliasKind ::= "aliasKindProjection" - | "aliasKindInherent" - | "aliasKindOpaque" - | "aliasKindWeak" -syntax AliasTy ::= aliasTy(defId:AliasDef, args: GenericArgs) - -syntax Abi ::= "abiRust" - | abiC(unwind: Bool) - | abiCdecl(unwind: Bool) - | abiStdcall(unwind: Bool) - | abiFastcall(unwind: Bool) - | abiVectorcall(unwind: Bool) - | abiThiscall(unwind: Bool) - | abiAapcs(unwind: Bool) - | abiWin64(unwind: Bool) - | abiSysV64(unwind: Bool) - | "abiPtxKernel" - | "abiMsp430Interrupt" - | "abiX86Interrupt" - | "abiEfiApi" - | "abiAvrInterrupt" - | "abiAvrNonBlockingInterrupt" - | "abiCCmseNonSecureCall" - | "abiWasm" - | abiSystem(unwind: Bool) - | "abiRustIntrinsic" - | "abiRustCall" - | "abiUnadjusted" - | "abiRustCold" - | "abiRiscvInterruptM" - | "abiRiscvInterruptS" - -syntax BoundTyKind ::= "boundTyKindAnon" - | boundTyKindParam(ParamDef, MIRString) -syntax BoundRegionKind ::= "boundRegionKindBrAnon" - | boundRegionKindBrNamed(BrNamedDef, MIRString) - | "boundRegionKindBrEnv" -syntax BoundVariableKind ::= boundVariableKindTy(BoundTyKind) - | boundVariableKindRegion(BoundRegionKind) - | "boundVariableKindConst" +syntax ForeignModule ::= foreignModule(defId: ForeignModuleDef, abi: Abi) [group(mir---def-id--abi)] + +syntax ForeignItemKind ::= foreignItemKindFn() [group(mir-enum), symbol(ForeignItemKind::Fn)] + | foreignItemKindStatic(StaticDef) [group(mir-enum), symbol(ForeignItemKind::Static)] + | foreignItemKindType(Ty) [group(mir-enum), symbol(ForeignItemKind::Type)] + +syntax AdtKind ::= "adtKindEnum" [group(mir-enum), symbol(AdtKind::Enum)] + | "adtKindUnion" [group(mir-enum), symbol(AdtKind::Union)] + | "adtKindStruct" [group(mir-enum), symbol(AdtKind::Struct)] + +syntax VariantDef ::= variantDef(idx: VariantIdx, adtDef: AdtDef) [group(mir---idx--adtDef)] + +syntax FieldDef ::= fieldDef(def: DefId, name: Symbol) [group(mir---def--name)] + +syntax GenericArg ::= genericArgKindLifetime(Region) [group(mir-enum), symbol(GenericArg::Lifetime)] + | genericArgKindType(Ty) [group(mir-enum), symbol(GenericArg::Type)] + | genericArgKindConst(TyConst) [group(mir-enum), symbol(GenericArg::Const)] + +syntax GenericArgs ::= List {GenericArg, ""} [group(mir-list), symbol(GenericArgs::append), terminator-symbol(GenericArgs::empty)] + +syntax TermKind ::= termKindType(Ty) [group(mir-enum), symbol(TermKind::Type)] + | termKindConst(TyConst) [group(mir-enum), symbol(TermKind::Const)] + +syntax AliasKind ::= "aliasKindProjection" [group(mir-enum), symbol(AliasKind::Projection)] + | "aliasKindInherent" [group(mir-enum), symbol(AliasKind::Inherent)] + | "aliasKindOpaque" [group(mir-enum), symbol(AliasKind::Opaque)] + | "aliasKindWeak" [group(mir-enum), symbol(AliasKind::Weak)] + +syntax AliasTy ::= aliasTy(defId:AliasDef, args: GenericArgs) [group(mir---defId--args)] + +syntax Abi ::= "abiRust" [group(mir-enum), symbol(Abi::Rust)] + | abiC(unwind: MIRBool) [group(mir-enum), symbol(Abi::C)] + | abiCdecl(unwind: MIRBool) [group(mir-enum), symbol(Abi::Cdecl)] + | abiStdcall(unwind: MIRBool) [group(mir-enum), symbol(Abi::Stdcall)] + | abiFastcall(unwind: MIRBool) [group(mir-enum), symbol(Abi::Fastcall)] + | abiVectorcall(unwind: MIRBool) [group(mir-enum), symbol(Abi::Vectorcall)] + | abiThiscall(unwind: MIRBool) [group(mir-enum), symbol(Abi::Thiscall)] + | abiAapcs(unwind: MIRBool) [group(mir-enum), symbol(Abi::Aapcs)] + | abiWin64(unwind: MIRBool) [group(mir-enum), symbol(Abi::Win64)] + | abiSysV64(unwind: MIRBool) [group(mir-enum), symbol(Abi::SysV64)] + | "abiPtxKernel" [group(mir-enum), symbol(Abi::PtxKernel)] + | "abiMsp430Interrupt" [group(mir-enum), symbol(Abi::Msp430Interrupt)] + | "abiX86Interrupt" [group(mir-enum), symbol(Abi::X86Interrupt)] + | "abiEfiApi" [group(mir-enum), symbol(Abi::EfiApi)] + | "abiAvrInterrupt" [group(mir-enum), symbol(Abi::AvrInterrupt)] + | "abiAvrNonBlockingInterrupt" [group(mir-enum), symbol(Abi::AvrNonBlockingInterrupt)] + | "abiCCmseNonSecureCall" [group(mir-enum), symbol(Abi::CCmseNonSecureCall)] + | "abiWasm" [group(mir-enum), symbol(Abi::Wasm)] + | abiSystem(unwind: MIRBool) [group(mir-enum), symbol(Abi::System)] + | "abiRustIntrinsic" [group(mir-enum), symbol(Abi::RustIntrinsic)] + | "abiRustCall" [group(mir-enum), symbol(Abi::RustCall)] + | "abiUnadjusted" [group(mir-enum), symbol(Abi::Unadjusted)] + | "abiRustCold" [group(mir-enum), symbol(Abi::RustCold)] + | "abiRiscvInterruptM" [group(mir-enum), symbol(Abi::RiscvInterruptM)] + | "abiRiscvInterruptS" [group(mir-enum), symbol(Abi::RiscvInterruptS)] + +syntax BoundTyKind ::= "boundTyKindAnon" [group(mir-enum), symbol(BoundTyKind::Anon)] + | boundTyKindParam(ParamDef, MIRString) [group(mir-enum), symbol(BoundTyKind::Param)] +syntax BoundRegionKind ::= "boundRegionKindBrAnon" [group(mir-enum), symbol(BoundRegionKind::BrAnon)] + | boundRegionKindBrNamed(BrNamedDef, MIRString) [group(mir-enum), symbol(BoundRegionKind::BrNamed)] + | "boundRegionKindBrEnv" [group(mir-enum), symbol(BoundRegionKind::BrEnv)] +syntax BoundVariableKind ::= boundVariableKindTy(BoundTyKind) [group(mir-enum), symbol(BoundVariableKind::Ty)] + | boundVariableKindRegion(BoundRegionKind) [group(mir-enum), symbol(BoundVariableKind::Region)] + | "boundVariableKindConst" [group(mir-enum), symbol(BoundVariableKind::Const)] syntax BoundVariableKindList ::= List {BoundVariableKind, ""} + [group(mir-list), symbol(BoundVariableKindList::append), terminator-symbol(BoundVariableKindList::empty)] -syntax FnSig ::= fnSig(inputsAndOutput: Tys, cVaradic: MIRBool, unsafety: Safety, abi: Abi) -syntax BinderForFnSig ::= binderForFnSig(value: FnSig, boundVars: BoundVariableKindList) -syntax PolyFnSig ::= BinderForFnSig +syntax FnSig ::= fnSig(inputsAndOutput: Tys, cVaradic: MIRBool, unsafety: Safety, abi: Abi) [group(mir---inputsAndOutput--cVariadic--unsafety--abi)] +syntax BinderForFnSig ::= binderForFnSig(value: FnSig, boundVars: BoundVariableKindList) [group(mir---value--boundVars)] +syntax PolyFnSig ::= BinderForFnSig [group(mir)] // Not needed this way. We could just do PolyFnSig ::= binderForFnSig(value: FnSig, boundVars: BoundVariableKindList). -syntax Ty ::= ty(MIRInt, TyKind) [symbol(ty)] - | ty(Int) [group(mir-int)] -syntax Tys ::= List {Ty, ""} - -syntax Pattern ::= patternRange(start: MaybeTyConst, end: MaybeTyConst, includeEnd: MIRBool) - -syntax TyConst ::= tyConst(kind: TyConstKind, id: TyConstId) -syntax TyConstId ::= tyConstId(Int) -syntax MaybeTyConst ::= someTyConst(TyConst) | "noTyConst" - -syntax MirConst ::= mirConst(kind: ConstantKind, ty: Ty, id: MirConstId) -syntax MirConstId ::= mirConstId(Int) - -syntax TyConstKind ::= tyConstKindParam(ParamConst) - | tyConstKindBound(DebruijinIndex, BoundVar) - | tyConstKindUnevaluated(ConstDef, GenericArgs) - | tyConstKindValue(Ty, Allocation) - | tyConstKindZSTValue(Ty) - -syntax DebruijinIndex ::= debruijinIndex(Int) -syntax UniverseIndex ::= universeIndex(Int) -syntax EarlyParamRegion ::= earlyParamRegion(index: MIRInt, name: Symbol) -syntax BoundVar ::= boundVar(Int) -syntax BoundRegion ::= boundRegion(var: BoundVar, kind: BoundRegionKind) -syntax PlaceholderForBoundRegion ::= placeholderForBoundRegion(universe: UniverseIndex, bound: BoundRegion) -syntax RegionKind ::= regionKindReEarlyParam(EarlyParamRegion) - | regionKindReBound(DebruijinIndex, BoundRegion) - | "regionKindReStatic" - | regionKindRePlaceholder(PlaceholderForBoundRegion) - | "regionKindReErased" -syntax Region ::= region(kind: RegionKind) +syntax Ty ::= ty(Int) [group(mir-int)] + +syntax Tys ::= List {Ty, ""} [group(mir-list), symbol(Tys::append), terminator-symbol(Tys::empty)] + +syntax Pattern ::= patternRange(start: MaybeTyConst, end: MaybeTyConst, includeEnd: MIRBool) [group(mir---start--end--includeEnd)] + +syntax TyConst ::= tyConst(kind: TyConstKind, id: TyConstId) [group(mir---kind--id)] +syntax TyConstId ::= tyConstId(Int) [group(mir-int)] +syntax MaybeTyConst ::= someTyConst(TyConst) [group(mir-option)] + | "noTyConst" [group(mir-option)] + +syntax MirConst ::= mirConst(kind: ConstantKind, ty: Ty, id: MirConstId) [group(mir---kind--ty--id)] +syntax MirConstId ::= mirConstId(Int) [group(mir-int)] + +syntax TyConstKind ::= tyConstKindParam(ParamConst) [group(mir-enum), symbol(TyConstKind::Param)] + | tyConstKindBound(DebruijinIndex, BoundVar) [group(mir-enum), symbol(TyConstKind::Bound)] + | tyConstKindUnevaluated(ConstDef, GenericArgs) [group(mir-enum), symbol(TyConstKind::Unevaluated)] + | tyConstKindValue(Ty, Allocation) [group(mir-enum), symbol(TyConstKind::Value)] + | tyConstKindZSTValue(Ty) [group(mir-enum), symbol(TyConstKind::ZSTValue)] + +syntax DebruijinIndex ::= debruijinIndex(Int) [group(mir-int)] +syntax UniverseIndex ::= universeIndex(Int) [group(mir-int)] +syntax BoundVar ::= boundVar(Int) [group(mir-int)] +syntax EarlyParamRegion ::= earlyParamRegion(index: MIRInt, name: Symbol) [group(mir---index--name)] +syntax BoundRegion ::= boundRegion(var: BoundVar, kind: BoundRegionKind) [group(mir---var--kind)] +syntax PlaceholderForBoundRegion ::= placeholderForBoundRegion(universe: UniverseIndex, bound: BoundRegion) [group(mir---universe--bound)] + +syntax RegionKind ::= regionKindReEarlyParam(EarlyParamRegion) [group(mir-enum), symbol(RegionKind::ReEarlyParam)] + | regionKindReBound(DebruijinIndex, BoundRegion) [group(mir-enum), symbol(RegionKind::ReBound)] + | "regionKindReStatic" [group(mir-enum), symbol(RegionKind::ReStatic)] + | regionKindRePlaceholder(PlaceholderForBoundRegion) [group(mir-enum), symbol(RegionKind::RePlaceholder)] + | "regionKindReErased" [group(mir-enum), symbol(RegionKind::ReErased)] +syntax Region ::= region(kind: RegionKind) [group(mir---kind)] syntax Span ::= span(Int) [group(mir-int)] -syntax ExistentialTraitRef ::= existentialTraitRef(defId: TraitDef, genericArgs: GenericArgs) -syntax ExistentialProjection ::= existentialProjection(defId: TraitDef, genericArgs: GenericArgs, term: TermKind) -syntax ExistentialPredicate ::= existentialPredicateTrait(ExistentialTraitRef) - | existentialPredicateProjection(ExistentialProjection) - | existentialPredicateAutoTrait(TraitDef) -syntax BinderForExistentialPredicate ::= binderForExistentialPredicate(value: ExistentialPredicate, boundVars: BoundVariableKindList) -syntax BindersForExistentialPredicate ::= List {BinderForExistentialPredicate, ""} - - syntax IntTy ::= "intTyIsize" [group(mir), symbol(IntTy::Isize)] - | "intTyI8" [group(mir), symbol(IntTy::I8)] - | "intTyI16" [group(mir), symbol(IntTy::I16)] - | "intTyI32" [group(mir), symbol(IntTy::I32)] - | "intTyI64" [group(mir), symbol(IntTy::I64)] - | "intTyI128" [group(mir), symbol(IntTy::I128)] - - syntax UintTy ::= "uintTyUsize" [group(mir), symbol(UintTy::Usize)] - | "uintTyU8" [group(mir), symbol(UintTy::U8)] - | "uintTyU16" [group(mir), symbol(UintTy::U16)] - | "uintTyU32" [group(mir), symbol(UintTy::U32)] - | "uintTyU64" [group(mir), symbol(UintTy::U64)] - | "uintTyU128" [group(mir), symbol(UintTy::U128)] - - syntax FloatTy ::= "floatTyF16" [group(mir), symbol(FloatTy::F16)] - | "floatTyF32" [group(mir), symbol(FloatTy::F32)] - | "floatTyF64" [group(mir), symbol(FloatTy::F64)] - | "floatTyF128" [group(mir), symbol(FloatTy::F128)] - - syntax Movability ::= "movabilityStatic" - | "movabilityMovable" - - syntax RigidTy ::= "rigidTyBool" [group(mir), symbol(RigidTy::Bool)] - | "rigidTyChar" [group(mir), symbol(RigidTy::Char)] - | rigidTyInt(IntTy) [group(mir), symbol(RigidTy::Int)] - | rigidTyUint(UintTy) [group(mir), symbol(RigidTy::Uint)] - | rigidTyFloat(FloatTy) [group(mir), symbol(RigidTy::Float)] - | rigidTyAdt(AdtDef, GenericArgs) - | rigidTyForeign(ForeignDef) - | "rigidTyStr" [group(mir), symbol(RigidTy::Str)] - | rigidTyArray(Ty, TyConst) - | rigidTyPat(Ty, Pattern) - | rigidTySlice(Ty) - | rigidTyRawPtr(Ty, Mutability) - | rigidTyRef(Region, Ty, Mutability) - | rigidTyFnDef(FnDef, GenericArgs) - | rigidTyFnPtr(PolyFnSig) - | rigidTyClosure(ClosureDef, GenericArgs) - | rigidTyCoroutine(CoroutineDef, GenericArgs, Movability) - | rigidTyDynamic(BindersForExistentialPredicate, Region, DynKind) - | "rigidTyNever" [group(mir), symbol(RigidTy::Never)] - | rigidTyTuple(Tys) - | rigidTyCoroutineWitness(CoroutineWitnessDef, GenericArgs) - | "rigidTyUnimplemented" [symbol(rigidTyUnimplemented), deprecated] // TODO: remove - -syntax TyKind ::= tyKindRigidTy(RigidTy) [group(mir), symbol(TyKind::RigidTy)] - | tyKindAlias(AliasKind, AliasTy) [group(mir), symbol(TyKind::Alias)] - | tyKindParam(ParamTy) [group(mir), symbol(TyKind::Param)] - | tyKindBound(MIRInt, BoundTy) [group(mir), symbol(TyKind::Bound)] - -syntax TypeAndMut ::= typeAndMut(ty: Ty, mutability: Mutability) - -syntax ParamTy ::= paramTy(index: MIRInt, name: MIRString) -syntax BoundTy ::= boundTy(var: MIRInt, kind: BoundTyKind) - -syntax Promoted ::= promoted(Int) -syntax MaybePromoted ::= somePromoted(Promoted) | "noPromoted" - -syntax Align ::= align(Int) [symbol(align)] -syntax ProvenanceMapEntry ::= provenanceMapEntry(provSize: MIRInt, allocId: AllocId) [symbol(provenanceMapEntry)] -syntax ProvenanceMapEntries ::= List {ProvenanceMapEntry, ""} [symbol(provenanceMapEntries), terminator-symbol(.provenanceMapEntries)] -syntax ProvenanceMap ::= provenanceMap(ptrs: ProvenanceMapEntries) [symbol(provenanceMap)] -syntax AllocByte ::= someByte(Int) [symbol(someByte)] - | "noByte" [symbol(noByte)] -syntax AllocBytes ::= List {AllocByte, ""} [symbol(maybeBytes), terminator-symbol(.maybeBytes)] +syntax ExistentialTraitRef ::= existentialTraitRef(defId: TraitDef, genericArgs: GenericArgs) [group(mir---defId--genericArgs)] + +syntax ExistentialProjection ::= existentialProjection(defId: TraitDef, genericArgs: GenericArgs, term: TermKind) [group(mir---defId--genericArgs--term)] + +syntax ExistentialPredicate ::= existentialPredicateTrait(ExistentialTraitRef) [group(mir-enum), symbol(ExistentialPredicate::Trait)] + | existentialPredicateProjection(ExistentialProjection) [group(mir-enum), symbol(ExistentialPredicate::Projection)] + | existentialPredicateAutoTrait(TraitDef) [group(mir-enum), symbol(ExistentialPredicate::AutoTrait)] + +syntax ExistentialPredicateBinder ::= existentialPredicateBinder(value: ExistentialPredicate, boundVars: BoundVariableKindList) + [group(mir---value--boundVars)] +syntax ExistentialPredicateBinders ::= List {ExistentialPredicateBinder, ""} + [group(mir-list), symbol(ExistentialPredicateBinders::append), terminator-symbol(ExistentialPredicateBinders::empty)] + + syntax IntTy ::= "intTyIsize" [group(mir-enum), symbol(IntTy::Isize)] + | "intTyI8" [group(mir-enum), symbol(IntTy::I8)] + | "intTyI16" [group(mir-enum), symbol(IntTy::I16)] + | "intTyI32" [group(mir-enum), symbol(IntTy::I32)] + | "intTyI64" [group(mir-enum), symbol(IntTy::I64)] + | "intTyI128" [group(mir-enum), symbol(IntTy::I128)] + + syntax UintTy ::= "uintTyUsize" [group(mir-enum), symbol(UintTy::Usize)] + | "uintTyU8" [group(mir-enum), symbol(UintTy::U8)] + | "uintTyU16" [group(mir-enum), symbol(UintTy::U16)] + | "uintTyU32" [group(mir-enum), symbol(UintTy::U32)] + | "uintTyU64" [group(mir-enum), symbol(UintTy::U64)] + | "uintTyU128" [group(mir-enum), symbol(UintTy::U128)] + + syntax FloatTy ::= "floatTyF16" [group(mir-enum), symbol(FloatTy::F16)] + | "floatTyF32" [group(mir-enum), symbol(FloatTy::F32)] + | "floatTyF64" [group(mir-enum), symbol(FloatTy::F64)] + | "floatTyF128" [group(mir-enum), symbol(FloatTy::F128)] + + syntax Movability ::= "movabilityStatic" [group(mir-enum), symbol(Movability::Static)] + | "movabilityMovable" [group(mir-enum), symbol(Movability::Movable)] + + syntax RigidTy ::= "rigidTyBool" [group(mir-enum), symbol(RigidTy::Bool)] + | "rigidTyChar" [group(mir-enum), symbol(RigidTy::Char)] + | rigidTyInt(IntTy) [group(mir-enum), symbol(RigidTy::Int)] + | rigidTyUint(UintTy) [group(mir-enum), symbol(RigidTy::Uint)] + | rigidTyFloat(FloatTy) [group(mir-enum), symbol(RigidTy::Float)] + | rigidTyAdt(AdtDef, GenericArgs) [group(mir-enum), symbol(RigidTy::Adt)] + | rigidTyForeign(ForeignDef) [group(mir-enum), symbol(RigidTy::Foreign)] + | "rigidTyStr" [group(mir-enum), symbol(RigidTy::Str)] + | rigidTyArray(Ty, TyConst) [group(mir-enum), symbol(RigidTy::Array)] + | rigidTyPat(Ty, Pattern) [group(mir-enum), symbol(RigidTy::Pat)] + | rigidTySlice(Ty) [group(mir-enum), symbol(RigidTy::Slice)] + | rigidTyRawPtr(Ty, Mutability) [group(mir-enum), symbol(RigidTy::RawPtr)] + | rigidTyRef(Region, Ty, Mutability) [group(mir-enum), symbol(RigidTy::Ref)] + | rigidTyFnDef(FnDef, GenericArgs) [group(mir-enum), symbol(RigidTy::FnDef)] + | rigidTyFnPtr(PolyFnSig) [group(mir-enum), symbol(RigidTy::FnPtr)] + | rigidTyClosure(ClosureDef, GenericArgs) [group(mir-enum), symbol(RigidTy::Closure)] + | rigidTyCoroutine(CoroutineDef, GenericArgs, Movability) [group(mir-enum), symbol(RigidTy::Coroutine)] + | rigidTyDynamic(ExistentialPredicateBinders, Region, DynKind) [group(mir-enum), symbol(RigidTy::Dynamic)] + | "rigidTyNever" [group(mir-enum), symbol(RigidTy::Never)] + | rigidTyTuple(Tys) [group(mir-enum), symbol(RigidTy::Tuple)] + | rigidTyCoroutineWitness(CoroutineWitnessDef, GenericArgs) [group(mir-enum), symbol(RigidTy::CoroutineWitness)] + | "rigidTyUnimplemented" [group(mir-enum), symbol(RigidTy::Unimplemented), deprecated] // TODO: remove + +syntax TyKind ::= tyKindRigidTy(RigidTy) [group(mir-enum), symbol(TyKind::RigidTy)] + | tyKindAlias(AliasKind, AliasTy) [group(mir-enum), symbol(TyKind::Alias)] + | tyKindParam(ParamTy) [group(mir-enum), symbol(TyKind::Param)] + | tyKindBound(MIRInt, BoundTy) [group(mir-enum), symbol(TyKind::Bound)] + +syntax TypeAndMut ::= typeAndMut(ty: Ty, mutability: Mutability) [group(mir---ty--mutability)] + +syntax ParamTy ::= paramTy(index: MIRInt, name: MIRString) [group(mir---index--name)] +syntax BoundTy ::= boundTy(var: MIRInt, kind: BoundTyKind) [group(mir---var--kind)] + +// syntax Promoted ::= promoted(Int) [group(mir-int)] +syntax MaybePromoted ::= promoted(Int) [group(mir-option-int)] + | "notPromoted" [group(mir-option)] + +syntax Align ::= align(Int) [group(mir-int), symbol(align)] + +// FIXME provSize and allocId are in a _list_ in json +syntax ProvenanceMapEntry ::= // provenanceMapEntry(provSize: MIRInt, allocId: AllocId) [group(mir), symbol(provenanceMapEntry)] + List [group(mir-klist-MIRInt)] + +syntax ProvenanceMapEntries ::= List {ProvenanceMapEntry, ""} + [group(mir-list), symbol(ProvenanceMapEntries::append), terminator-symbol(ProvenanceMapEntries::empty)] + +syntax ProvenanceMap ::= provenanceMap(ptrs: ProvenanceMapEntries) [group(mir---ptrs), symbol(provenanceMap)] + +// FIXME why are the bytes optional? What does it mean??? +syntax AllocByte ::= someByte(Int) [group(mir-option-int), symbol(someByte)] + | "noByte" [group(mir-option), symbol(noByte)] +syntax AllocBytes ::= List {AllocByte, ""} [group(mir-list), symbol(AllocBytes::append), terminator-symbol(AllocBytes::empty)] syntax Allocation ::= allocation( bytes: AllocBytes, provenance: ProvenanceMap, align: Align, - mutability: Mutability) [symbol(allocation)] + mutability: Mutability) + [group(mir---bytes--provenance--align--mutability), symbol(allocation)] -syntax ConstantKind ::= constantKindTy(TyConst) - | constantKindAllocated(Allocation) - | constantKindUnevaluated(UnevaluatedConst) - | constantKindParam(ParamConst) - | "constantKindZeroSized" - | "constantKindNoOp" [symbol(constantKindNoOp)] - | constantKindFnDef(id: Int) [symbol(constantKindFnDef)] - | constantKindIntrinsic(name: Symbol) [symbol(constantKindIntrinsic)] +syntax ConstantKind ::= constantKindTy(TyConst) [group(mir-enum), symbol(ConstantKind::Ty)] + | constantKindAllocated(Allocation) [group(mir-enum), symbol(ConstantKind::Allocated)] + | constantKindUnevaluated(UnevaluatedConst) [group(mir-enum), symbol(ConstantKind::Unevaluated)] + | constantKindParam(ParamConst) [group(mir-enum), symbol(ConstantKind::Param)] + | "constantKindZeroSized" [group(mir-enum), symbol(ConstantKind::ZeroSized)] + | "constantKindNoOp" [group(mir-enum), symbol(ConstantKind::NoOp)] + | constantKindFnDef(id: Int) [group(mir-enum), symbol(ConstantKind::FnDef)] + | constantKindIntrinsic(name: Symbol) [group(mir-enum), symbol(ConstantKind::Intrinsic)] -syntax ParamConst ::= paramConst(index: MIRInt, name: MIRString) +syntax ParamConst ::= paramConst(index: MIRInt, name: MIRString) [group(mir---index--name)] syntax UnevaluatedConst ::= unevaluatedConst(def: ConstDef, args: GenericArgs, promoted: MaybePromoted) - -syntax TraitSpecializationKind ::= "traitSpecializationKindNone" - | "traitSpecializationKindMarker" - | "traitSpecializationKindAlwaysApplicable" - -syntax Ident ::= ident(Opaque) -syntax Idents ::= List {Ident, ""} -syntax MaybeIdents ::= someIdents(Idents) | "noIdents" -syntax TraitDecl ::= traitDecl(defId: TraitDef, unsafety: Safety, parenSugar: MIRBool, hasAutoImpl: MIRBool, isMarker: MIRBool, isCoinductive: MIRBool, skipArrayDuringMethodDispatch: MIRBool, specializationKind: TraitSpecializationKind, mustImplementOneOf: MaybeIdents, implementViaObject: MIRBool, denyExplicitImpl: MIRBool) - -syntax TraitRef ::= traitRef(defId: TraitDef, args: GenericArgs) - -syntax GenericParamDefKind ::= "genericParamDefKindLifetime" - | genericParamDefKindType(hasDefault: MIRBool, synthetic: MIRBool) - | genericParamDefKindConst(hasDefault: Bool) + [group(mir---def--args--promoted)] + +syntax TraitSpecializationKind ::= "traitSpecializationKindNone" [group(mir-enum), symbol(TraitSpecializationKind::None)] + | "traitSpecializationKindMarker" [group(mir-enum), symbol(TraitSpecializationKind::Marker)] + | "traitSpecializationKindAlwaysApplicable" [group(mir-enum), symbol(TraitSpecializationKind::AlwaysApplicable)] + +syntax Ident ::= ident(Opaque) [group(mir)] +syntax Idents ::= List {Ident, ""} [group(mir-list), symbol(Idents::append), terminator-symbol(Idents::empty)] +syntax MaybeIdents ::= someIdents(Idents) [group(mir-option)] + | "noIdents" [group(mir-option)] +syntax TraitDecl ::= traitDecl( + defId: TraitDef + , unsafety: Safety + , parenSugar: MIRBool + , hasAutoImpl: MIRBool + , isMarker: MIRBool + , isCoinductive: MIRBool + , skipArrayDuringMethodDispatch: MIRBool + , specializationKind: TraitSpecializationKind + , mustImplementOneOf: MaybeIdents + , implementViaObject: MIRBool + , denyExplicitImpl: MIRBool) + [group(mir---defId--unsafety--parenSugar--hasAutoImpl--isMarker--isCoinductive--skipArrayDuringMethodDispatch--specializationKind--mustImplementOneOf--implementViaObject--denyExplicitImpl)] + +syntax TraitRef ::= traitRef(defId: TraitDef, args: GenericArgs) [group(mir---defId--args)] + +syntax GenericParamDefKind ::= "genericParamDefKindLifetime" [group(mir-enum), symbol(GenericParamDefKind::Lifetime)] + | genericParamDefKindType(hasDefault: MIRBool, synthetic: MIRBool) [group(mir-enum), symbol(GenericParamDefKind::Type)] + | genericParamDefKindConst(hasDefault: Bool) [group(mir-enum), symbol(GenericParamDefKind::Const)] syntax GenericParamDef ::= genericParamDef(name: Symbol, defId: GenericDef, index: MIRInt, pureWrtDrop: MIRBool, kind: GenericParamDefKind) -syntax MaybeGenericDef ::= someGenericDef(GenericDef) | "noGenericDef" -syntax GenericParamDefs ::= List {GenericParamDef, ""} -syntax GenericDefAndIdxPair ::= genericDefAndIdxPair(GenericDef, MIRInt) + [group(mir---name--defId--index--purtWrtDrop--kind)] +syntax MaybeGenericDef ::= someGenericDef(GenericDef) [group(mir-option)] + | "noGenericDef" [group(mir-option)] +syntax GenericParamDefs ::= List {GenericParamDef, ""} [group(mir-list), symbol(GenericParamDefs::append), terminator-symbol(GenericParamDefs::empty)] + +syntax GenericDefAndIdxPair ::= genericDefAndIdxPair(GenericDef, MIRInt) [group(mir)] syntax GenericDefAndIdxPairs ::= List {GenericDefAndIdxPair, ""} -syntax MaybeSpan ::= someSpan(Span) | "noSpan" -syntax Generics ::= generics(parent: MaybeGenericDef, parentCount: MIRInt, params: GenericParamDefs, paramDefIdToIndex: GenericDefAndIdxPairs, hasSelf: MIRBool, hasLateBoundRegions: MaybeSpan, hostEffectIndex: MaybeInt) + [group(mir-list), symbol(GenericDefAndIdxPairs::append), terminator-symbol(GenericDefAndIdxPairs::empty)] + +syntax MaybeSpan ::= someSpan(Span) [group(mir-option)] + | "noSpan" [group(mir-option)] +syntax Generics ::= generics( + parent: MaybeGenericDef + , parentCount: MIRInt + , params: GenericParamDefs + , paramDefIdToIndex: GenericDefAndIdxPairs + , hasSelf: MIRBool + , hasLateBoundRegions: MaybeSpan + , hostEffectIndex: MaybeInt) + [group(mir---parent--parentCount--params--paramDefIdToIndex--hasSelf--hasLateBoundRegions--hostEffectIndex)] + +syntax MaybeTraitDef ::= someTraitDef(TraitDef) [group(mir-option)] + | "noTraitDef" [group(mir-option)] -syntax MaybeTraitDef ::= someTraitDef(TraitDef) | "noTraitDef" syntax PredicateKindAndSpanPair ::= predicateKindAndSpanPair(predicateKind: PredicateKind, span: Span) + [group(mir---predicateKind--span)] syntax PredicateKindAndSpanPairs ::= List {PredicateKindAndSpanPair, ""} -syntax GenericPredicates ::= genericPredicates(parent: MaybeTraitDef, predicates: PredicateKindAndSpanPairs) + [group(mir-list), symbol(PredicateKindAndSpanPairs::append), terminator-symbol(PredicateKindAndSpanPairs::empty)] -syntax PredicateKind ::= predicateKindClause(ClauseKind) - | predicateKindObjectSafe(TraitDef) - | predicateKindSubType(SubtypePredicate) - | predicateKindCoerce(CoercePredicate) - | predicateKindConstEquate(TyConst, TyConst) - | "predicateKindAmbiguous" - | predicateKindAliasRelate(TermKind, TermKind, AliasRelationDirection) - -syntax ClauseKind ::= clauseKindTrait(TraitPredicate) - | clauseKindRegionOutlives(RegionOutlivesPredicate) - | clauseKindTypeOutlives(TypeOutlivesPredicate) - | clauseKindProjection(ProjectionPredicate) - | clauseKindConstArgHasType(TyConst, Ty) - | clauseKindWellFormed(GenericArgKind) - | clauseKindConstEvaluatable(TyConst) - -syntax TraitPredicate ::= traitPredicate(traitDef: TraitDef, polarity: PredicatePolarity) -syntax RegionOutlivesPredicate ::= regionOutlivesPredicate(Region, Region) -syntax TypeOutlivesPredicate ::= typeOutlivesPredicate(Ty, Region) -syntax ProjectionPredicate ::= projectionPredicate(projectionTy: AliasTy, term: TermKind) - -syntax SubtypePredicate ::= subtypePredicate(a: Ty, b: Ty) -syntax CoercePredicate ::= coercePredicate(a: Ty, b: Ty) -syntax AliasRelationDirection ::= "aliasRelationDirectionEquate" - | "aliasRelationDirectionSubtype" - -syntax ClosureKind ::= "closureKindFn" - | "closureKindFnMut" - | "closureKindFnOnce" - -syntax ImplPolarity ::= "implPolarityPositive" - | "implPolarityNegative" - | "implPolarityReservation" -syntax PredicatePolarity ::= "predicatePolarityPositive" - | "predicatePolarityNegative" +syntax GenericPredicates ::= genericPredicates(parent: MaybeTraitDef, predicates: PredicateKindAndSpanPairs) + [group(mir---parent--predicates)] + +syntax PredicateKind ::= predicateKindClause(ClauseKind) [group(mir-enum), symbol(PredicateKind::Clause)] + | predicateKindObjectSafe(TraitDef) [group(mir-enum), symbol(PredicateKind::ObjectSafe)] + | predicateKindSubType(SubtypePredicate) [group(mir-enum), symbol(PredicateKind::SubType)] + | predicateKindCoerce(CoercePredicate) [group(mir-enum), symbol(PredicateKind::Coerce)] + | predicateKindConstEquate(TyConst, TyConst) [group(mir-enum), symbol(PredicateKind::ConstEquate)] + | "predicateKindAmbiguous" [group(mir-enum), symbol(PredicateKind::Ambiguous)] + | predicateKindAliasRelate(TermKind, TermKind, AliasRelationDirection) [group(mir-enum), symbol(PredicateKind::AliasRelate)] + +syntax ClauseKind ::= clauseKindTrait(TraitPredicate) [group(mir-enum), symbol(ClauseKind::Trait)] + | clauseKindRegionOutlives(RegionOutlivesPredicate) [group(mir-enum), symbol(ClauseKind::RegionOutlives)] + | clauseKindTypeOutlives(TypeOutlivesPredicate) [group(mir-enum), symbol(ClauseKind::TypeOutlives)] + | clauseKindProjection(ProjectionPredicate) [group(mir-enum), symbol(ClauseKind::Projection)] + | clauseKindConstArgHasType(TyConst, Ty) [group(mir-enum), symbol(ClauseKind::ConstArgHasType)] + | clauseKindWellFormed(GenericArg) [group(mir-enum), symbol(ClauseKind::WellFormed)] + | clauseKindConstEvaluatable(TyConst) [group(mir-enum), symbol(ClauseKind::ConstEvaluatable)] + +syntax TraitPredicate ::= traitPredicate(traitDef: TraitDef, polarity: PredicatePolarity) [group(mir---traitDef--polarity)] +syntax RegionOutlivesPredicate ::= regionOutlivesPredicate(Region, Region) [group(mir)] // FIXME field names?? +syntax TypeOutlivesPredicate ::= typeOutlivesPredicate(Ty, Region) [group(mir)] // FIXME field names?? +syntax ProjectionPredicate ::= projectionPredicate(projectionTy: AliasTy, term: TermKind) [group(mir---projectionTy--term)] + +syntax SubtypePredicate ::= subtypePredicate(a: Ty, b: Ty) [group(mir---a--b)] +syntax CoercePredicate ::= coercePredicate(a: Ty, b: Ty) [group(mir---a--b)] +syntax AliasRelationDirection ::= "aliasRelationDirectionEquate" [group(mir-enum), symbol(AliasRelationDirection::Equate)] + | "aliasRelationDirectionSubtype" [group(mir-enum), symbol(AliasRelationDirection::Subtype)] + +syntax ClosureKind ::= "closureKindFn" [group(mir-enum), symbol(ClosureKind::Fn)] + | "closureKindFnMut" [group(mir-enum), symbol(ClosureKind::FnMut)] + | "closureKindFnOnce" [group(mir-enum), symbol(ClosureKind::FnOnce)] + +syntax ImplPolarity ::= "implPolarityPositive" [group(mir-enum), symbol(ImplPolarity::Positive)] + | "implPolarityNegative" [group(mir-enum), symbol(ImplPolarity::Negative)] + | "implPolarityReservation" [group(mir-enum), symbol(ImplPolarity::Reservation)] +syntax PredicatePolarity ::= "predicatePolarityPositive" [group(mir-enum), symbol(PredicatePolarity::Positive)] + | "predicatePolarityNegative" [group(mir-enum), symbol(PredicatePolarity::Negative)] endmodule -``` \ No newline at end of file +``` diff --git a/package/version b/package/version index b2ccc30ee..a7c15395c 100644 --- a/package/version +++ b/package/version @@ -1 +1 @@ -0.3.38 +0.3.39