use hir_lang::CaptureMode;
use crate::pick::Pick;
use crate::template::TemplateId;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum RecordShape {
#[default]
Auto,
Named,
Tuple,
Unit,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct TemplateUse {
pub(crate) template: TemplateId,
pub(crate) first: u32,
pub(crate) len: u32,
}
impl TemplateUse {
#[must_use]
pub const fn template(&self) -> TemplateId {
self.template
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum Arch<K> {
Module {
name: Pick<K>,
items: Pick<K>,
},
Pass {
inner: Pick<K>,
},
Splice {
items: Pick<K>,
},
Unsupported,
Let {
pat: Pick<K>,
ty: Pick<K>,
init: Pick<K>,
else_: Pick<K>,
mutable: bool,
hoist: bool,
},
ExprStmt {
expr: Pick<K>,
},
Defer {
body: Pick<K>,
},
Static {
name: Pick<K>,
ty: Pick<K>,
init: Pick<K>,
},
GlobalDecl {
names: Pick<K>,
},
Import {
path: Pick<K>,
alias: Pick<K>,
},
Fn {
name: Pick<K>,
generics: Pick<K>,
params: Pick<K>,
ret: Pick<K>,
throws: Pick<K>,
body: Pick<K>,
where_: Pick<K>,
},
Record {
name: Pick<K>,
generics: Pick<K>,
fields: Pick<K>,
shape: RecordShape,
},
Sum {
name: Pick<K>,
generics: Pick<K>,
variants: Pick<K>,
},
Interface {
name: Pick<K>,
generics: Pick<K>,
supers: Pick<K>,
items: Pick<K>,
},
Class {
name: Pick<K>,
generics: Pick<K>,
bases: Pick<K>,
interfaces: Pick<K>,
members: Pick<K>,
mixin: bool,
},
Impl {
generics: Pick<K>,
interface: Pick<K>,
self_ty: Pick<K>,
items: Pick<K>,
},
Alias {
name: Pick<K>,
generics: Pick<K>,
ty: Pick<K>,
},
AssocType {
name: Pick<K>,
bounds: Pick<K>,
default: Pick<K>,
},
Const {
name: Pick<K>,
ty: Pick<K>,
value: Pick<K>,
},
GlobalVar {
name: Pick<K>,
ty: Pick<K>,
init: Pick<K>,
mutable: bool,
},
MixinUse {
mixins: Pick<K>,
},
FieldDecl {
name: Pick<K>,
ty: Pick<K>,
default: Pick<K>,
},
VariantDecl {
name: Pick<K>,
fields: Pick<K>,
discriminant: Pick<K>,
shape: RecordShape,
},
GenericParam {
name: Pick<K>,
bounds: Pick<K>,
ty: Pick<K>,
default: Pick<K>,
},
WherePred {
subject: Pick<K>,
bounds: Pick<K>,
},
Param {
pat: Pick<K>,
ty: Pick<K>,
default: Pick<K>,
},
Capture {
name: Pick<K>,
},
Path {
segments: Pick<K>,
global: Pick<K>,
qself: Pick<K>,
qtrait: Pick<K>,
},
Segment {
name: Pick<K>,
args: Pick<K>,
},
AssocBinding {
name: Pick<K>,
ty: Pick<K>,
},
Unary {
op: Pick<K>,
operand: Pick<K>,
},
Binary {
lhs: Pick<K>,
op: Pick<K>,
rhs: Pick<K>,
},
Postfix {
operand: Pick<K>,
op: Pick<K>,
},
Assign {
target: Pick<K>,
op: Pick<K>,
value: Pick<K>,
},
RefAssign {
target: Pick<K>,
source: Pick<K>,
},
Call {
callee: Pick<K>,
args: Pick<K>,
},
Arg {
name: Pick<K>,
value: Pick<K>,
},
Member {
base: Pick<K>,
member: Pick<K>,
args: Pick<K>,
call: Pick<K>,
},
MethodCall {
receiver: Pick<K>,
method: Pick<K>,
generics: Pick<K>,
args: Pick<K>,
},
DynMember {
base: Pick<K>,
name: Pick<K>,
args: Pick<K>,
call: Pick<K>,
},
Index {
base: Pick<K>,
index: Pick<K>,
},
VarVar {
inner: Pick<K>,
},
Append {
base: Pick<K>,
},
Tuple {
elems: Pick<K>,
},
Array {
elems: Pick<K>,
},
Map {
entries: Pick<K>,
},
MapEntry {
key: Pick<K>,
value: Pick<K>,
},
RecordLit {
path: Pick<K>,
fields: Pick<K>,
base: Pick<K>,
},
FieldInit {
name: Pick<K>,
value: Pick<K>,
},
Repeat {
elem: Pick<K>,
count: Pick<K>,
},
Cast {
expr: Pick<K>,
ty: Pick<K>,
},
Borrow {
expr: Pick<K>,
},
Deref {
inner: Pick<K>,
},
Block {
stmts: Pick<K>,
tail: Pick<K>,
label: Pick<K>,
tail_from_last: bool,
},
If {
cond: Pick<K>,
then: Pick<K>,
else_: Pick<K>,
},
Match {
scrutinee: Pick<K>,
arms: Pick<K>,
},
Arm {
pat: Pick<K>,
guard: Pick<K>,
body: Pick<K>,
},
Loop {
label: Pick<K>,
body: Pick<K>,
},
Break {
label: Pick<K>,
value: Pick<K>,
},
Continue {
label: Pick<K>,
},
Return {
value: Pick<K>,
},
Throw {
value: Pick<K>,
},
Try {
body: Pick<K>,
catches: Pick<K>,
finally: Pick<K>,
},
Catch {
types: Pick<K>,
name: Pick<K>,
body: Pick<K>,
},
Await {
inner: Pick<K>,
},
Yield {
value: Pick<K>,
},
Spawn {
inner: Pick<K>,
},
Closure {
params: Pick<K>,
ret: Pick<K>,
captures: Pick<K>,
body: Pick<K>,
implicit: Option<CaptureMode>,
},
Template(TemplateUse),
WildPat,
RestPat {
bind: Pick<K>,
},
BindPat {
name: Pick<K>,
sub: Pick<K>,
},
TuplePat {
elems: Pick<K>,
},
CtorPat {
path: Pick<K>,
elems: Pick<K>,
},
RecordPat {
path: Pick<K>,
fields: Pick<K>,
},
FieldPat {
name: Pick<K>,
pat: Pick<K>,
},
OrPat {
alts: Pick<K>,
},
RangePat {
lo: Pick<K>,
hi: Pick<K>,
},
RefPat {
inner: Pick<K>,
},
SlicePat {
elems: Pick<K>,
},
TypeTestPat {
ty: Pick<K>,
pat: Pick<K>,
},
TupleTy {
elems: Pick<K>,
},
ArrayTy {
elem: Pick<K>,
len: Pick<K>,
},
SliceTy {
elem: Pick<K>,
},
RefTy {
inner: Pick<K>,
region: Pick<K>,
},
PtrTy {
inner: Pick<K>,
},
NullableTy {
inner: Pick<K>,
},
FnTy {
params: Pick<K>,
ret: Pick<K>,
},
ObjectTy {
bounds: Pick<K>,
},
ImplTy {
bounds: Pick<K>,
},
}
impl<K> Arch<K> {
#[must_use]
pub const fn pass(n: u16) -> Self {
Self::Pass {
inner: Pick::Nth(n),
}
}
#[must_use]
pub const fn binary() -> Self {
Self::Binary {
lhs: Pick::Nth(0),
op: Pick::Nth(1),
rhs: Pick::Nth(2),
}
}
#[must_use]
pub const fn prefix() -> Self {
Self::Unary {
op: Pick::Nth(0),
operand: Pick::Nth(1),
}
}
#[must_use]
pub const fn name(&self) -> &'static str {
match self {
Self::Module { .. } => "module",
Self::Pass { .. } => "pass",
Self::Splice { .. } => "splice",
Self::Unsupported => "unsupported",
Self::Let { .. } => "let",
Self::ExprStmt { .. } => "expression statement",
Self::Defer { .. } => "defer",
Self::Static { .. } => "static",
Self::GlobalDecl { .. } => "global declaration",
Self::Import { .. } => "import",
Self::Fn { .. } => "function",
Self::Record { .. } => "record",
Self::Sum { .. } => "sum",
Self::Interface { .. } => "interface",
Self::Class { .. } => "class",
Self::Impl { .. } => "impl",
Self::Alias { .. } => "alias",
Self::AssocType { .. } => "associated type",
Self::Const { .. } => "constant",
Self::GlobalVar { .. } => "global variable",
Self::MixinUse { .. } => "mixin use",
Self::FieldDecl { .. } => "field",
Self::VariantDecl { .. } => "variant",
Self::GenericParam { .. } => "generic parameter",
Self::WherePred { .. } => "where predicate",
Self::Param { .. } => "parameter",
Self::Capture { .. } => "capture",
Self::Path { .. } => "path",
Self::Segment { .. } => "path segment",
Self::AssocBinding { .. } => "associated-type binding",
Self::Unary { .. } => "unary",
Self::Binary { .. } => "binary",
Self::Postfix { .. } => "postfix",
Self::Assign { .. } => "assignment",
Self::RefAssign { .. } => "reference assignment",
Self::Call { .. } => "call",
Self::Arg { .. } => "argument",
Self::Member { .. } => "member",
Self::MethodCall { .. } => "method call",
Self::DynMember { .. } => "dynamic member",
Self::Index { .. } => "index",
Self::VarVar { .. } => "variable variable",
Self::Append { .. } => "append",
Self::Tuple { .. } => "tuple",
Self::Array { .. } => "array",
Self::Map { .. } => "map",
Self::MapEntry { .. } => "map entry",
Self::RecordLit { .. } => "record literal",
Self::FieldInit { .. } => "field initializer",
Self::Repeat { .. } => "repeat",
Self::Cast { .. } => "cast",
Self::Borrow { .. } => "borrow",
Self::Deref { .. } => "dereference",
Self::Block { .. } => "block",
Self::If { .. } => "if",
Self::Match { .. } => "match",
Self::Arm { .. } => "match arm",
Self::Loop { .. } => "loop",
Self::Break { .. } => "break",
Self::Continue { .. } => "continue",
Self::Return { .. } => "return",
Self::Throw { .. } => "throw",
Self::Try { .. } => "try",
Self::Catch { .. } => "catch",
Self::Await { .. } => "await",
Self::Yield { .. } => "yield",
Self::Spawn { .. } => "spawn",
Self::Closure { .. } => "closure",
Self::Template(_) => "template",
Self::WildPat => "wildcard pattern",
Self::RestPat { .. } => "rest pattern",
Self::BindPat { .. } => "binding pattern",
Self::TuplePat { .. } => "tuple pattern",
Self::CtorPat { .. } => "constructor pattern",
Self::RecordPat { .. } => "record pattern",
Self::FieldPat { .. } => "field pattern",
Self::OrPat { .. } => "or-pattern",
Self::RangePat { .. } => "range pattern",
Self::RefPat { .. } => "reference pattern",
Self::SlicePat { .. } => "slice pattern",
Self::TypeTestPat { .. } => "type-test pattern",
Self::TupleTy { .. } => "tuple type",
Self::ArrayTy { .. } => "array type",
Self::SliceTy { .. } => "slice type",
Self::RefTy { .. } => "reference type",
Self::PtrTy { .. } => "pointer type",
Self::NullableTy { .. } => "nullable type",
Self::FnTy { .. } => "function type",
Self::ObjectTy { .. } => "object type",
Self::ImplTy { .. } => "impl type",
}
}
}