mod enter;
mod finish;
mod token;
mod tpl;
use alloc::collections::BTreeMap;
use alloc::string::String;
use alloc::vec::Vec;
use hir_lang::{
Arg, ArgKind, BinderId, BinderKind, Builder, Capture, Effects, Expr, ExprId, FieldInit,
FieldPat, GenericArg, GenericParam, Hir, HirError, Item, ItemId, ItemKind, List, MapEntry,
Name, NodeRef, Ns, Origin, Param, ParamKind, Pat, PatId, Path, PathId, Res, Segment, Site,
Span, Stmt, StmtId, Ty, TyId, UnitId, VariantId, WherePred,
};
use intern_lang::{Interner, Symbol};
use syntax_lang::{Element, Node, TokenKind};
use crate::arch::Arch;
use crate::mapping::{EffectMode, Mapping, OpSpec, TokenRole};
use crate::pick::{self, Kid, Labeler, Pick};
use crate::problem::{Context, LowerError, Problem, ProblemKind};
use crate::template::TemplateId;
pub(crate) type AttrRange = (u32, u32);
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub struct Budget {
pub max_nodes: u64,
pub max_expansion_depth: u32,
}
impl Default for Budget {
fn default() -> Self {
Self {
max_nodes: 1 << 24,
max_expansion_depth: 64,
}
}
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct Lowered {
pub hir: Hir,
pub problems: Vec<Problem>,
}
impl Lowered {
#[must_use]
pub fn has_problems(&self) -> bool {
!self.problems.is_empty()
}
}
pub struct Lowerer<'m, K> {
mapping: &'m Mapping<K>,
budget: Budget,
unit: UnitId,
labeler: Option<&'m dyn Labeler<K>>,
}
impl<'m, K> Lowerer<'m, K>
where
K: Copy + Ord + TokenKind,
{
#[must_use]
pub fn new(mapping: &'m Mapping<K>) -> Self {
Self {
mapping,
budget: Budget::default(),
unit: UnitId::default(),
labeler: None,
}
}
#[must_use]
pub fn with_budget(mut self, budget: Budget) -> Self {
self.budget = budget;
self
}
#[must_use]
pub fn with_unit(mut self, unit: UnitId) -> Self {
self.unit = unit;
self
}
#[must_use]
pub fn with_labeler(mut self, labeler: &'m dyn Labeler<K>) -> Self {
self.labeler = Some(labeler);
self
}
pub fn lower(
&self,
tree: &Node<K>,
source: &str,
names: &mut Interner,
) -> Result<Lowered, LowerError> {
Run::new(self, source, names)?.run(tree)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct PatSite {
pub(crate) param: bool,
pub(crate) mutable: bool,
pub(crate) arm: bool,
pub(crate) bound: bool,
pub(crate) persist: bool,
}
impl PatSite {
pub(crate) const LOCAL: Self = Self {
param: false,
mutable: false,
arm: false,
bound: false,
persist: false,
};
pub(crate) const ARM: Self = Self {
param: false,
mutable: false,
arm: true,
bound: false,
persist: false,
};
}
#[derive(Clone, Copy, Debug)]
pub(crate) struct Persist {
pub(crate) tmp: BinderId,
pub(crate) sym: Symbol,
pub(crate) span: Span,
}
#[derive(Clone, Copy, Debug)]
pub(crate) enum Piece {
Text(hir_lang::TextRef, Span),
Expr,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum Want {
Root,
Expr,
Stmt,
Member,
Pat(PatSite),
Ty,
Path(Ns),
Segment,
Param,
Arg,
Arm,
Capture,
Field,
Rule,
Variant,
Generic,
GArg,
Where,
Entry,
Init,
FieldPat(PatSite),
}
impl Want {
pub(crate) const fn context(self) -> Context {
match self {
Self::Root | Self::Stmt => Context::Statement,
Self::Expr => Context::Expression,
Self::Member => Context::Member,
Self::Pat(_) | Self::FieldPat(_) => Context::Pattern,
Self::Ty => Context::Type,
Self::Path(_) => Context::Path,
Self::Segment => Context::Segment,
Self::Param => Context::Parameter,
Self::Arg => Context::Argument,
Self::Arm => Context::Arm,
Self::Capture => Context::Capture,
Self::Field => Context::Field,
Self::Rule => Context::Member,
Self::Variant => Context::Variant,
Self::Generic | Self::GArg | Self::Where => Context::Generic,
Self::Entry | Self::Init => Context::Entry,
}
}
pub(crate) const fn takes_expr(self) -> bool {
matches!(
self,
Self::Expr | Self::Stmt | Self::Arg | Self::Entry | Self::GArg
)
}
}
#[derive(Clone, Copy, Debug)]
pub(crate) enum Val {
Err,
Expr(ExprId),
Stmt(StmtId),
Item(ItemId),
Spill(u32, u32),
Pat(PatId),
Rest(Option<PatId>),
Ty(TyId),
Path(PathId),
Seg(Segment),
Param(Param, Span, AttrRange),
Marker(ParamKind),
Arg(Arg),
Arm(hir_lang::Arm),
Cap(Capture),
Field(hir_lang::FieldId, bool),
Variant(VariantId),
Generic(GenericParam),
GArg(GenericArg),
Where(WherePred),
Entry(MapEntry),
Init(FieldInit),
FieldPat(FieldPat),
Rule(hir_lang::MixinRule),
}
#[derive(Clone, Copy, Debug)]
pub(crate) struct Slot {
pub(crate) v: Val,
pub(crate) span: Span,
pub(crate) place: bool,
}
#[derive(Clone, Copy)]
pub(crate) enum Task<'t, K> {
Elem(&'t Element<K>, Want),
Node(&'t Node<K>, Want),
Finish,
Mark,
}
#[derive(Clone, Copy, Debug)]
pub(crate) enum Build {
Arch,
Op(OpSpec),
Compound { spec: OpSpec, nodes_at: u64 },
Template {
id: TemplateId,
label: Option<BinderId>,
nodes_at: u64,
},
RootWrap,
HoistedLet { name: Symbol, name_span: Span },
}
#[derive(Clone, Copy, Debug)]
pub(crate) struct Frame<K> {
pub(crate) arch: Arch<K>,
pub(crate) build: Build,
pub(crate) want: Want,
pub(crate) span: Span,
pub(crate) vals_base: usize,
pub(crate) counts_base: usize,
pub(crate) nfields: usize,
pub(crate) spill_base: usize,
pub(crate) label_mark: usize,
pub(crate) mods: u32,
pub(crate) fx: bool,
pub(crate) or: bool,
pub(crate) name: Option<(Symbol, Span)>,
pub(crate) alias: Option<(Symbol, Span)>,
pub(crate) binder: Option<BinderId>,
pub(crate) index: Option<u32>,
pub(crate) flag: bool,
pub(crate) path_root: hir_lang::PathRoot,
pub(crate) attrs: AttrRange,
pub(crate) aux: (u32, u32),
pub(crate) loop_mark: usize,
}
#[derive(Clone, Copy, Debug)]
pub(crate) struct Fx {
pub(crate) declared: Effects,
pub(crate) inferred: Effects,
pub(crate) hoist_base: usize,
pub(crate) decl_base: usize,
pub(crate) recv: Recv,
pub(crate) recv_captured: bool,
pub(crate) loop_base: usize,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum Recv {
None,
Visible,
Hidden,
}
#[derive(Clone, Copy, Debug)]
pub(crate) struct LoopEntry {
pub(crate) label: Option<BinderId>,
pub(crate) span: Span,
}
pub(crate) struct Run<'a, 't, K> {
pub(crate) m: &'a Mapping<K>,
pub(crate) src: &'t str,
pub(crate) labeler: Option<&'a dyn Labeler<K>>,
pub(crate) names: &'a mut Interner,
pub(crate) b: Builder,
pub(crate) nodes: u64,
pub(crate) budget: Budget,
pub(crate) syms: Vec<Symbol>,
pub(crate) empty: Symbol,
pub(crate) sym_failed: bool,
pub(crate) tasks: Vec<Task<'t, K>>,
pub(crate) vals: Vec<Slot>,
pub(crate) frames: Vec<Frame<K>>,
pub(crate) counts: Vec<usize>,
pub(crate) spill: Vec<Slot>,
pub(crate) kids: Vec<Kid<'t, K>>,
pub(crate) kids2: Vec<Kid<'t, K>>,
pub(crate) sel: Vec<&'t Element<K>>,
pub(crate) labels: BTreeMap<Symbol, Vec<BinderId>>,
pub(crate) label_log: Vec<Symbol>,
pub(crate) fx: Vec<Fx>,
pub(crate) hoist: Vec<(Symbol, Span)>,
pub(crate) declared: Vec<Symbol>,
pub(crate) or_depth: u32,
pub(crate) or_map: BTreeMap<Symbol, BinderId>,
pub(crate) problems: Vec<Problem>,
pub(crate) text: Vec<u8>,
pub(crate) scratch: String,
pub(crate) bufs: Vec<Vec<Slot>>,
pub(crate) tpl_scratch: tpl::TplScratch,
pub(crate) lists: Lists,
pub(crate) tfields: Vec<(Pick<K>, Want, bool)>,
pub(crate) attr_elems: Vec<&'t Element<K>>,
pub(crate) attr_pool: Vec<hir_lang::Attr>,
pub(crate) pending_attrs: AttrRange,
pub(crate) persist: Vec<Persist>,
pub(crate) persist_marks: Vec<(u32, u32)>,
pub(crate) pieces: Vec<Piece>,
pub(crate) hoist_sym: Symbol,
pub(crate) compound_sym: Symbol,
pub(crate) place_sym: Symbol,
pub(crate) recv_sym: Option<Symbol>,
pub(crate) level_sym: Symbol,
pub(crate) loops: Vec<LoopEntry>,
}
#[derive(Default)]
pub(crate) struct Lists {
pub(crate) exprs: Vec<ExprId>,
pub(crate) tys: Vec<TyId>,
pub(crate) args: Vec<Arg>,
pub(crate) arms: Vec<hir_lang::Arm>,
pub(crate) stmts: Vec<StmtId>,
pub(crate) params: Vec<hir_lang::ParamId>,
pub(crate) gargs: Vec<GenericArg>,
}
impl<'a, 't, K> Run<'a, 't, K>
where
K: Copy + Ord + TokenKind,
{
fn new(
cfg: &Lowerer<'a, K>,
src: &'t str,
names: &'a mut Interner,
) -> Result<Self, LowerError> {
let empty = names
.try_intern("")
.map_err(|_| LowerError::SymbolSpaceExhausted)?;
let hoist_sym = names
.try_intern("hoist")
.map_err(|_| LowerError::SymbolSpaceExhausted)?;
let compound_sym = names
.try_intern("compound")
.map_err(|_| LowerError::SymbolSpaceExhausted)?;
let place_sym = names
.try_intern("p")
.map_err(|_| LowerError::SymbolSpaceExhausted)?;
let level_sym = names
.try_intern("break_level")
.map_err(|_| LowerError::SymbolSpaceExhausted)?;
let mut syms = Vec::with_capacity(cfg.mapping.strings.len());
for s in &cfg.mapping.strings {
syms.push(
names
.try_intern(s)
.map_err(|_| LowerError::SymbolSpaceExhausted)?,
);
}
let recv_sym = cfg
.mapping
.policy
.implicit_receiver
.and_then(|r| syms.get(r.0 as usize).copied());
Ok(Self {
m: cfg.mapping,
src,
labeler: cfg.labeler,
names,
b: Builder::for_unit(cfg.unit),
nodes: 0,
budget: cfg.budget,
syms,
empty,
sym_failed: false,
tasks: Vec::new(),
vals: Vec::new(),
frames: Vec::new(),
counts: Vec::new(),
spill: Vec::new(),
kids: Vec::new(),
kids2: Vec::new(),
sel: Vec::new(),
labels: BTreeMap::new(),
label_log: Vec::new(),
fx: Vec::new(),
hoist: Vec::new(),
declared: Vec::new(),
or_depth: 0,
or_map: BTreeMap::new(),
problems: Vec::new(),
text: Vec::new(),
scratch: String::new(),
bufs: Vec::new(),
tpl_scratch: tpl::TplScratch::default(),
lists: Lists::default(),
tfields: Vec::new(),
attr_elems: Vec::new(),
attr_pool: Vec::new(),
pending_attrs: (0, 0),
persist: Vec::new(),
persist_marks: Vec::new(),
pieces: Vec::new(),
hoist_sym,
compound_sym,
place_sym,
recv_sym,
level_sym,
loops: Vec::new(),
})
}
fn run(mut self, tree: &'t Node<K>) -> Result<Lowered, LowerError> {
self.tasks.push(Task::Node(tree, Want::Root));
while let Some(task) = self.tasks.pop() {
match task {
Task::Elem(Element::Node(n), want) => self.lower_node(n, want),
Task::Elem(Element::Token(t), want) => self.lower_token(t, want),
Task::Node(n, want) => self.lower_node(n, want),
Task::Finish => self.finish(),
Task::Mark => {
let depth = u32::try_from(self.frames.len()).unwrap_or(u32::MAX);
let len = u32::try_from(self.persist.len()).unwrap_or(u32::MAX);
self.persist_marks.push((depth, len));
}
}
if self.nodes > self.budget.max_nodes {
return Err(LowerError::NodeBudget {
limit: self.budget.max_nodes,
});
}
if self.sym_failed {
return Err(LowerError::SymbolSpaceExhausted);
}
}
let root = match self.vals.pop().map(|s| s.v) {
Some(Val::Item(root)) => root,
_ => {
self.b.set_origin(Origin::new(tree.span()));
self.b.module(None, &[])
}
};
let (hir, errors) = self.b.finish_lenient(root).map_err(LowerError::Hir)?;
let mut problems = self.problems;
problems.reserve(errors.len());
for e in errors {
let span = hir_span(&hir, &e);
problems.push(Problem {
kind: ProblemKind::Hir(e),
span,
});
}
problems.sort_by_key(|p| p.span.start());
Ok(Lowered { hir, problems })
}
fn lower_node(&mut self, node: &'t Node<K>, want: Want) {
let span = node.span();
if self.m.is_error(node.kind()) {
self.report(ProblemKind::SyntaxError, span);
let v = self.error_val(want, span);
self.push(v, span);
return;
}
let mut attrs = core::mem::take(&mut self.attr_elems);
pick::collect_kids(node, self.labeler, self.m, &mut self.kids, Some(&mut attrs));
self.pending_attrs = (0, 0);
if !attrs.is_empty() {
self.pending_attrs = self.lower_attrs(&attrs);
}
self.attr_elems = attrs;
let (start, end) = self.m.rule_range(node.kind());
let mut chosen = None;
for &(_, rule) in self.m.by_kind.get(start..end).unwrap_or(&[]) {
let Some(rule) = self.m.rules.get(rule as usize) else {
continue;
};
if rule.when.is_absent() || pick::single(rule.when, &self.kids, self.m).is_some() {
chosen = Some(rule.arch);
break;
}
}
match chosen {
Some(arch) => self.enter(node, arch, want),
None => {
self.report(ProblemKind::Unmapped, span);
let v = self.error_val(want, span);
self.push(v, span);
}
}
if self.pending_attrs.1 > 0 {
self.pending_attrs = (0, 0);
self.report(ProblemKind::MisplacedAttribute, span);
}
}
pub(crate) fn push(&mut self, v: Val, span: Span) {
self.vals.push(Slot {
v,
span,
place: false,
});
}
pub(crate) fn push_place(&mut self, v: Val, span: Span, place: bool) {
self.vals.push(Slot { v, span, place });
}
pub(crate) fn plan(&mut self, mut frame: Frame<K>, fields: &[(Pick<K>, Want, bool)]) {
let counts_base = self.counts.len();
self.sel.clear();
for &(p, _, many) in fields {
let before = self.sel.len();
if many {
pick::list(p, &self.kids, self.m, &mut self.sel);
} else if let Some(e) = pick::single(p, &self.kids, self.m) {
self.sel.push(e);
}
self.counts.push(self.sel.len() - before);
}
self.drop_shared_children(fields, counts_base);
frame.counts_base = counts_base;
frame.nfields = fields.len();
frame.vals_base = self.vals.len();
frame.spill_base = self.spill.len();
self.open(frame);
self.tasks.push(Task::Finish);
let mut end = self.sel.len();
for (i, &(_, want, _)) in fields.iter().enumerate().rev() {
let n = self.counts.get(counts_base + i).copied().unwrap_or(0);
let start = end.saturating_sub(n);
if let Some(slice) = self.sel.get(start..end) {
for &e in slice.iter().rev() {
self.tasks.push(Task::Elem(e, want));
}
}
end = start;
}
self.sel.clear();
}
fn drop_shared_children(&mut self, fields: &[(Pick<K>, Want, bool)], counts_base: usize) {
let mut offset = 0;
for (i, &(_, _, many)) in fields.iter().enumerate() {
let c = self.counts.get(counts_base + i).copied().unwrap_or(0);
if !many && c == 1 {
if let Some(&e) = self.sel.get(offset) {
let earlier = self.sel.get(..offset).unwrap_or(&[]);
if earlier.iter().any(|&x| core::ptr::eq(x, e)) {
let _ = self.sel.remove(offset);
if let Some(slot) = self.counts.get_mut(counts_base + i) {
*slot = 0;
}
self.report(ProblemKind::AmbiguousChild, e.span());
continue;
}
}
}
offset += c;
}
}
pub(crate) fn plan_marked(&mut self, mut frame: Frame<K>, fields: &[(Pick<K>, Want, bool)]) {
let counts_base = self.counts.len();
self.sel.clear();
for &(p, _, many) in fields {
let before = self.sel.len();
if many {
pick::list(p, &self.kids, self.m, &mut self.sel);
} else if let Some(e) = pick::single(p, &self.kids, self.m) {
self.sel.push(e);
}
self.counts.push(self.sel.len() - before);
}
self.drop_shared_children(fields, counts_base);
frame.counts_base = counts_base;
frame.nfields = fields.len();
frame.vals_base = self.vals.len();
frame.spill_base = self.spill.len();
self.open(frame);
self.tasks.push(Task::Finish);
self.tasks.push(Task::Mark);
let mut end = self.sel.len();
for i in (0..fields.len()).rev() {
let n = self.counts.get(counts_base + i).copied().unwrap_or(0);
let start = end.saturating_sub(n);
if let Some(slice) = self.sel.get(start..end) {
let want = fields.get(i).map_or(Want::Expr, |f| f.1);
for &e in slice.iter().rev() {
self.tasks.push(Task::Elem(e, want));
}
}
self.tasks.push(Task::Mark);
end = start;
}
self.sel.clear();
}
pub(crate) fn frame(&self, arch: Arch<K>, want: Want, span: Span) -> Frame<K> {
Frame {
arch,
build: Build::Arch,
want,
span,
vals_base: 0,
counts_base: 0,
nfields: 0,
spill_base: 0,
label_mark: self.label_log.len(),
mods: 0,
fx: false,
or: false,
name: None,
alias: None,
binder: None,
index: None,
flag: false,
path_root: hir_lang::PathRoot::Relative,
attrs: (0, 0),
aux: (0, 0),
loop_mark: self.loops.len(),
}
}
pub(crate) fn open(&mut self, mut frame: Frame<K>) {
frame.attrs = core::mem::take(&mut self.pending_attrs);
self.frames.push(frame);
}
pub(crate) fn field_range(&self, f: &Frame<K>, i: usize) -> (usize, usize) {
let counts = self
.counts
.get(f.counts_base..f.counts_base + f.nfields)
.unwrap_or(&[]);
let start = f.vals_base + counts.iter().take(i).sum::<usize>();
let len = counts.get(i).copied().unwrap_or(0);
(start, start + len)
}
pub(crate) fn one(&self, f: &Frame<K>, i: usize) -> Val {
self.slot(f, i).map_or(Val::Err, |s| s.v)
}
pub(crate) fn slot(&self, f: &Frame<K>, i: usize) -> Option<Slot> {
let (s, e) = self.field_range(f, i);
if s < e {
self.vals.get(s).copied()
} else {
None
}
}
pub(crate) fn present(&self, f: &Frame<K>, i: usize) -> bool {
let (s, e) = self.field_range(f, i);
s < e
}
pub(crate) fn many(&mut self, f: &Frame<K>, i: usize) -> Vec<Slot> {
let mut out = self.bufs.pop().unwrap_or_default();
out.clear();
let (s, e) = self.field_range(f, i);
for j in s..e {
match self.vals.get(j).copied() {
Some(Slot {
v: Val::Spill(ss, sl),
..
}) => {
let (ss, sl) = (ss as usize, sl as usize);
if let Some(run) = self.spill.get(ss..ss.saturating_add(sl)) {
out.extend_from_slice(run);
}
}
Some(Slot { v: Val::Err, .. }) | None => {}
Some(slot) => out.push(slot),
}
}
out
}
pub(crate) fn give(&mut self, mut buf: Vec<Slot>) {
buf.clear();
self.bufs.push(buf);
}
pub(crate) fn report(&mut self, kind: ProblemKind, span: Span) {
self.problems.push(Problem { kind, span });
}
pub(crate) fn missing_expr(&mut self, field: &'static str, span: Span) -> ExprId {
self.report(ProblemKind::MissingField { field }, span);
self.err_expr(span)
}
pub(crate) fn at(&mut self, span: Span) {
self.b.set_origin(Origin::new(span));
}
pub(crate) fn ex(&mut self, e: Expr) -> ExprId {
self.nodes += 1;
self.b.expr(e)
}
pub(crate) fn st(&mut self, s: Stmt) -> StmtId {
self.nodes += 1;
self.b.stmt(s)
}
pub(crate) fn pt(&mut self, p: Pat) -> PatId {
self.nodes += 1;
self.b.pat(p)
}
pub(crate) fn ty(&mut self, t: Ty) -> TyId {
self.nodes += 1;
self.b.ty(t)
}
pub(crate) fn it(&mut self, i: Item) -> ItemId {
self.nodes += 1;
self.b.item(i)
}
pub(crate) fn path(&mut self, p: Path) -> PathId {
self.nodes += 1;
self.b.path(p)
}
pub(crate) fn binder(&mut self, name: Name, kind: BinderKind, mutable: bool) -> BinderId {
self.nodes += 1;
self.b
.binder(hir_lang::Binder::new(name, kind).with_mutable(mutable))
}
pub(crate) fn list<T: hir_lang::Pooled>(&mut self, items: &[T]) -> List<T> {
self.nodes += items.len() as u64;
self.b.list(items)
}
pub(crate) fn err_expr(&mut self, span: Span) -> ExprId {
self.at(span);
self.ex(Expr::Err)
}
pub(crate) fn name_path(&mut self, sym: Symbol, span: Span, ns: Ns) -> PathId {
self.at(span);
let seg = Segment::new(Name::new(sym), Origin::new(span));
let segs = self.list(&[seg]);
self.path(Path::new(segs, ns))
}
pub(crate) fn name_expr(&mut self, sym: Symbol, span: Span) -> ExprId {
let p = self.name_path(sym, span, Ns::Value);
self.ex(Expr::Path(p))
}
pub(crate) fn error_val(&mut self, want: Want, span: Span) -> Val {
self.at(span);
match want {
Want::Root => {
self.nodes += 1;
Val::Item(self.b.module(None, &[]))
}
Want::Member => Val::Item(self.it(Item::new(None, ItemKind::Err))),
Want::Expr => Val::Expr(self.ex(Expr::Err)),
Want::Stmt => Val::Stmt(self.st(Stmt::Err)),
Want::Pat(_) => Val::Pat(self.pt(Pat::Err)),
Want::Ty => Val::Ty(self.ty(Ty::Err)),
Want::Path(_) => {
let mut p = Path::new(List::EMPTY, Ns::Value);
p.res = Res::Err;
Val::Path(self.path(p))
}
Want::Param => {
let pat = self.pt(Pat::Err);
Val::Param(Param::new(pat), span, (0, 0))
}
Want::Arg => {
let e = self.ex(Expr::Err);
Val::Arg(Arg::positional(e))
}
Want::Entry => {
let e = self.ex(Expr::Err);
Val::Entry(MapEntry {
key: None,
value: e,
})
}
Want::GArg => {
let t = self.ty(Ty::Err);
Val::GArg(GenericArg::Ty(t))
}
Want::Segment
| Want::Arm
| Want::Capture
| Want::Field
| Want::Variant
| Want::Generic
| Want::Where
| Want::Init
| Want::Rule
| Want::FieldPat(_) => Val::Err,
}
}
pub(crate) fn not_here(&mut self, want: Want, span: Span) {
self.report(
ProblemKind::NotAllowedHere {
expected: want.context(),
},
span,
);
let v = self.error_val(want, span);
self.push(v, span);
}
pub(crate) fn adapt_expr(&mut self, e: ExprId, place: bool, want: Want, span: Span) -> Val {
match want {
Want::Expr | Want::Stmt => Val::Expr(e),
Want::Arg => Val::Arg(Arg {
kind: ArgKind::Positional,
value: e,
place: place && self.m.policy.place_args == crate::PlaceArgs::Places,
}),
Want::Entry => Val::Entry(MapEntry {
key: None,
value: e,
}),
Want::GArg => Val::GArg(GenericArg::Const(e)),
_ => {
self.report(
ProblemKind::NotAllowedHere {
expected: want.context(),
},
span,
);
self.error_val(want, span)
}
}
}
pub(crate) fn text_of(&mut self, span: Span) -> &'t str {
let (s, e) = (span.start().to_usize(), span.end().to_usize());
match self.src.get(s..e) {
Some(t) => t,
None => {
self.report(ProblemKind::BadSpan, span);
""
}
}
}
pub(crate) fn intern(&mut self, s: &str) -> Symbol {
match self.names.try_intern(s) {
Ok(sym) => sym,
Err(_) => {
self.sym_failed = true;
self.empty
}
}
}
pub(crate) fn sym(&self, i: u32) -> Symbol {
self.syms.get(i as usize).copied().unwrap_or(self.empty)
}
pub(crate) fn name_of(&mut self, elem: &'t Element<K>) -> Option<(Symbol, Span)> {
let mut cur = elem;
loop {
match cur {
Element::Token(t) => {
let span = t.span();
let strip = match self.m.role_for(t.kind()) {
Some(TokenRole::Name) | None => 0,
Some(
TokenRole::Var { sigil }
| TokenRole::Label { sigil }
| TokenRole::Lifetime { sigil },
) => usize::from(sigil),
Some(_) => return None,
};
let text = self.text_of(span);
let name = text.get(strip..).unwrap_or("");
return Some((self.intern(name), span));
}
Element::Node(n) => {
pick::collect_kids(n, self.labeler, self.m, &mut self.kids2, None);
let arch = self.m.rule_for(n.kind()).copied();
let inner = match arch {
Some(Arch::Pass { inner } | Arch::Segment { name: inner, .. }) => {
pick::single(inner, &self.kids2, self.m)
}
Some(Arch::Path { segments, .. }) => {
let mut out = Vec::new();
pick::list(segments, &self.kids2, self.m, &mut out);
if out.len() == 1 {
out.first().copied()
} else {
None
}
}
_ => None,
};
cur = inner?;
}
}
}
}
pub(crate) fn mods(&self, arch: &Arch<K>) -> u32 {
if self.m.modifiers.is_empty() && self.m.arch_modifiers.is_empty() {
return 0;
}
let name = (!self.m.arch_modifiers.is_empty()).then(|| arch.lsf_name());
let mut bits = 0;
for kid in &self.kids {
match kid.elem {
Element::Token(t) => {
bits |= crate::mapping::modifier_bits(self.m, t.kind(), name);
}
Element::Node(n) => {
if crate::pick::KindSets::is_container(self.m, n.kind()) {
for c in n.child_tokens() {
bits |= crate::mapping::modifier_bits(self.m, c.kind(), name);
}
}
}
}
}
bits
}
pub(crate) fn push_label(&mut self, sym: Symbol, b: BinderId) {
self.labels.entry(sym).or_default().push(b);
self.label_log.push(sym);
}
pub(crate) fn pop_labels(&mut self, mark: usize) {
while self.label_log.len() > mark {
if let Some(sym) = self.label_log.pop() {
if let Some(stack) = self.labels.get_mut(&sym) {
let _ = stack.pop();
}
}
}
}
pub(crate) fn find_label(&self, sym: Symbol) -> Option<BinderId> {
self.labels.get(&sym).and_then(|s| s.last().copied())
}
pub(crate) fn push_fx(&mut self, declared: Effects) {
self.fx.push(Fx {
declared,
inferred: Effects::NONE,
hoist_base: self.hoist.len(),
decl_base: self.declared.len(),
recv: Recv::None,
recv_captured: false,
loop_base: self.loops.len(),
});
}
pub(crate) fn recv_state(&self) -> Recv {
self.fx.last().map_or(Recv::None, |f| f.recv)
}
pub(crate) fn set_recv(&mut self, recv: Recv) {
if let Some(top) = self.fx.last_mut() {
top.recv = recv;
}
}
pub(crate) fn infer(&mut self, effect: Effects) {
if let Some(top) = self.fx.last_mut() {
top.inferred = top.inferred.union(effect);
}
}
pub(crate) fn hoist_name(&mut self, sym: Symbol, span: Span) {
if !self.fx.is_empty() {
self.hoist.push((sym, span));
}
}
pub(crate) fn declare_name(&mut self, sym: Symbol) {
if !self.fx.is_empty() {
self.declared.push(sym);
}
}
pub(crate) fn pop_fx(&mut self, span: Span) -> (Effects, Vec<StmtId>) {
let Some(fx) = self.fx.pop() else {
return (Effects::NONE, Vec::new());
};
let policy = self.m.policy;
let mut effects = fx.declared;
for (mode, flag) in [
(policy.throws, Effects::THROWS),
(policy.yields, Effects::YIELD),
(policy.asyncs, Effects::ASYNC),
] {
let add = match mode {
EffectMode::Declared => false,
EffectMode::Inferred => fx.inferred.contains(flag),
EffectMode::Always => true,
};
if add {
effects = effects.union(flag);
}
}
let mut stmts = Vec::new();
if self.hoist.len() > fx.hoist_base {
let mut names: Vec<(Symbol, Span)> = self.hoist.split_off(fx.hoist_base);
let mut declared: Vec<Symbol> = self.declared.split_off(fx.decl_base);
declared.sort();
names.sort_by(|a, b| a.0.cmp(&b.0).then(a.1.start().cmp(&b.1.start())));
names.dedup_by(|later, first| later.0 == first.0);
names.retain(|(s, _)| declared.binary_search(s).is_err());
names.sort_by_key(|(_, sp)| sp.start());
for (sym, sp) in names {
self.at(sp);
let b = self.binder(Name::new(sym), BinderKind::Local, true);
let pat = self.pt(Pat::Bind {
binder: b,
mode: hir_lang::BindMode::Value,
sub: None,
});
stmts.push(self.st(Stmt::Let {
pat,
ty: None,
init: None,
else_: None,
}));
}
self.at(span);
} else {
self.hoist.truncate(fx.hoist_base);
self.declared.truncate(fx.decl_base);
}
(effects, stmts)
}
pub(crate) fn persist_binder(&mut self, sym: Symbol, span: Span) -> BinderId {
let expn = self.b.expansion(hir_lang::Expansion {
kind: hir_lang::ExpnKind::Desugar,
name: self.hoist_sym,
call_site: span,
parent: hir_lang::ExpnId::ROOT,
def_site: hir_lang::ExpnId::ROOT,
});
self.at(span);
let tmp = self.binder(Name::marked(sym, expn), BinderKind::Local, true);
self.hoist_name(sym, span);
self.persist.push(Persist { tmp, sym, span });
tmp
}
pub(crate) fn persist_assigns(&mut self, binds: &[Persist], out: &mut Vec<StmtId>) {
for p in binds {
let target = self.name_expr(p.sym, p.span);
self.at(p.span);
let value = self.b.use_binder(p.tmp);
self.nodes += 2;
let assign = self.ex(Expr::Assign {
target,
op: None,
value,
});
out.push(self.st(Stmt::Expr(assign)));
}
}
pub(crate) fn with_assigns(&mut self, binds: &[Persist], body: ExprId, span: Span) -> ExprId {
if binds.is_empty() {
return body;
}
let mut stmts = Vec::with_capacity(binds.len());
self.persist_assigns(binds, &mut stmts);
self.at(span);
let list = self.list(&stmts);
self.ex(Expr::Block(hir_lang::Block {
stmts: list,
tail: Some(body),
label: None,
is_unsafe: false,
}))
}
fn lower_attrs(&mut self, elems: &[&'t Element<K>]) -> AttrRange {
let start = u32::try_from(self.attr_pool.len()).unwrap_or(u32::MAX);
let mut kids = Vec::new();
let mut arg_kids = Vec::new();
let mut args_sel: Vec<&'t Element<K>> = Vec::new();
for &e in elems {
let Element::Node(n) = e else { continue };
let Some(Arch::Attr { name, args }) = self.m.rule_for(n.kind()).copied() else {
continue;
};
pick::collect_kids(n, self.labeler, self.m, &mut kids, None);
let Some(name_elem) = pick::single(name, &kids, self.m) else {
self.report(ProblemKind::MissingField { field: "name" }, e.span());
continue;
};
let name_span = name_elem.span();
let sym = match name_elem {
Element::Token(_) => self.name_of(name_elem).map(|(s, _)| s),
Element::Node(_) => {
let text = self.text_of(name_span).trim();
Some(self.intern(text))
}
}
.unwrap_or(self.empty);
args_sel.clear();
pick::list(args, &kids, self.m, &mut args_sel);
let mut out_args: Vec<hir_lang::AttrArg> = Vec::new();
for &a in &args_sel {
let arg_rule = match a {
Element::Node(an) => self.m.rule_for(an.kind()).copied(),
Element::Token(_) => None,
};
if let (Some(Arch::AttrArg { key, value }), Element::Node(an)) = (arg_rule, a) {
pick::collect_kids(an, self.labeler, self.m, &mut arg_kids, None);
let key = pick::single(key, &arg_kids, self.m)
.and_then(|k| self.name_of(k))
.map(|(s, sp)| hir_lang::Ident::new(s, sp));
let value = pick::single(value, &arg_kids, self.m);
let value = match value {
Some(v) => match self.attr_value(v) {
Some(v) => Some(v),
None => continue,
},
None => None,
};
if key.is_none() && value.is_none() {
continue;
}
out_args.push(hir_lang::AttrArg { key, value });
} else if let Some(v) = self.attr_value(a) {
out_args.push(hir_lang::AttrArg {
key: None,
value: Some(v),
});
}
}
let list = self.list(&out_args);
self.attr_pool.push(hir_lang::Attr {
name: hir_lang::Ident::new(sym, name_span),
args: list,
});
}
let end = u32::try_from(self.attr_pool.len()).unwrap_or(u32::MAX);
(start, end.saturating_sub(start))
}
fn attr_value(&mut self, e: &'t Element<K>) -> Option<hir_lang::AttrValue> {
match e {
Element::Token(t) => {
let span = t.span();
match self.m.role_for(t.kind()) {
Some(TokenRole::Name | TokenRole::Var { .. }) => {
let (sym, _) = self.token_name(span, TokenRole::Name);
Some(hir_lang::AttrValue::Name(hir_lang::Ident::new(sym, span)))
}
Some(
role @ (TokenRole::Int
| TokenRole::Float
| TokenRole::Number
| TokenRole::Str(_)
| TokenRole::RawStr
| TokenRole::Heredoc(_)
| TokenRole::Char(_)
| TokenRole::Bytes(_)
| TokenRole::True
| TokenRole::False
| TokenRole::Null),
) => match self.token_lit(role, span, false) {
token::Decoded::Lit(l) => Some(hir_lang::AttrValue::Lit(l)),
token::Decoded::Bad => None,
},
_ => {
self.report(ProblemKind::AttributeArgument, span);
None
}
}
}
Element::Node(n) => {
let span = n.span();
match self.m.rule_for(n.kind()).copied() {
Some(Arch::Path { .. } | Arch::Segment { .. }) => {
let text = self.text_of(span).trim();
let sym = self.intern(text);
Some(hir_lang::AttrValue::Name(hir_lang::Ident::new(sym, span)))
}
Some(Arch::Pass { .. }) => match self.name_of(e) {
Some((sym, sp)) => {
Some(hir_lang::AttrValue::Name(hir_lang::Ident::new(sym, sp)))
}
None => {
self.report(ProblemKind::AttributeArgument, span);
None
}
},
Some(Arch::Unary { op, operand }) => {
let mut kids = Vec::new();
pick::collect_kids(n, self.labeler, self.m, &mut kids, None);
let op_tok = pick::single(op, &kids, self.m);
let neg = match op_tok {
Some(Element::Token(t)) => {
let text = if self.m.has_op_text() {
self.text_of(t.span())
} else {
""
};
matches!(
self.m.op(crate::mapping::Fixity::Prefix, t.kind(), text),
Some(OpSpec::Op(hir_lang::OpKind::Neg))
)
}
_ => false,
};
let num = match pick::single(operand, &kids, self.m) {
Some(Element::Token(t)) => Some(*t),
_ => None,
};
match (
neg,
num.and_then(|t| self.m.role_for(t.kind()).map(|r| (t, r))),
) {
(
true,
Some((
t,
role @ (TokenRole::Int | TokenRole::Float | TokenRole::Number),
)),
) => match self.token_lit(role, t.span(), true) {
token::Decoded::Lit(l) => Some(hir_lang::AttrValue::Lit(l)),
token::Decoded::Bad => None,
},
_ => {
self.report(ProblemKind::AttributeArgument, span);
None
}
}
}
_ => {
self.report(ProblemKind::AttributeArgument, span);
None
}
}
}
}
}
pub(crate) fn attach_attrs(&mut self, v: &mut Val, attrs: AttrRange, span: Span) {
let (s, l) = (attrs.0 as usize, attrs.1 as usize);
let Some(list) = self.attr_pool.get(s..s.saturating_add(l)) else {
return;
};
let list: Vec<hir_lang::Attr> = list.to_vec();
let node = match *v {
Val::Item(i) => Some(NodeRef::Item(i)),
Val::Expr(e) => Some(NodeRef::Expr(e)),
Val::Stmt(st) => Some(NodeRef::Stmt(st)),
Val::Pat(p) => Some(NodeRef::Pat(p)),
Val::Ty(t) => Some(NodeRef::Ty(t)),
Val::Path(p) => Some(NodeRef::Path(p)),
Val::Field(f, _) => Some(NodeRef::Field(f)),
Val::Variant(var) => Some(NodeRef::Variant(var)),
Val::Arg(a) => Some(NodeRef::Expr(a.value)),
Val::Param(p, sp, _) => {
*v = Val::Param(p, sp, attrs);
return;
}
Val::Spill(ss, sl) => {
let (ss, sl) = (ss as usize, sl as usize);
let nodes: Vec<NodeRef> = self
.spill
.get(ss..ss.saturating_add(sl))
.unwrap_or(&[])
.iter()
.filter_map(|slot| match slot.v {
Val::Item(i) => Some(NodeRef::Item(i)),
Val::Stmt(st) => Some(NodeRef::Stmt(st)),
Val::Expr(e) => Some(NodeRef::Expr(e)),
_ => None,
})
.collect();
for n in nodes {
self.b.attach(n, &list);
}
return;
}
_ => None,
};
match node {
Some(n) => self.b.attach(n, &list),
None => self.report(ProblemKind::MisplacedAttribute, span),
}
}
pub(crate) fn wrap_hoisted(&mut self, hoisted: &[StmtId], body: ExprId, span: Span) -> ExprId {
if hoisted.is_empty() {
return body;
}
self.at(span);
let stmts = self.list(hoisted);
self.ex(Expr::Block(hir_lang::Block {
stmts,
tail: Some(body),
label: None,
is_unsafe: false,
}))
}
}
fn hir_span(hir: &Hir, e: &HirError) -> Span {
match e.node() {
Some(n) => hir.origin(n).span,
None => match e {
HirError::BinderBoundTwice { binder, .. }
| HirError::BinderKind { binder, .. }
| HirError::DuplicateBinding { binder, .. } => hir.binder_origin(*binder).span,
HirError::Dangling {
site: Site::Binder(b),
..
} => hir.binder_origin(*b).span,
HirError::Dangling {
site: Site::Expansion(x),
..
}
| HirError::ExpansionOrder { expn: x } => {
hir.expansion(*x).map_or(Span::empty(0), |x| x.call_site)
}
_ => hir.origin(NodeRef::Item(hir.root())).span,
},
}
}