From e266d42c48288aa8a8e2cf50144e961ee22bdd52 Mon Sep 17 00:00:00 2001 From: Mike Gerwitz Date: Thu, 18 May 2023 01:32:28 -0400 Subject: [PATCH] tamer: asg::air::AirAggregateCtx: Tuple struct => named struct As evidenced by this change, the tuple syntax was no longer serving us well. But the real reason for this change is to prepare for the addition of a fourth field: the index, taken from `Asg`. DEV-13162 --- tamer/src/asg/air.rs | 83 ++++++++++++++++++++++---------------------- 1 file changed, 42 insertions(+), 41 deletions(-) diff --git a/tamer/src/asg/air.rs b/tamer/src/asg/air.rs index fb25e937..ada3dcb2 100644 --- a/tamer/src/asg/air.rs +++ b/tamer/src/asg/air.rs @@ -347,16 +347,26 @@ impl AirAggregate { /// Additional parser context, /// including the ASG and parser stack frames. -/// -/// [`ObjectIndex`] lookups perform reverse linear searches beginning from -/// the last stack frame until a non-[`None`] value is found; -/// this creates an environment whereby inner contexts shadow outer. -/// Missing values create holes, -/// much like a prototype chain. -/// In practice, -/// this should only have to search the last two frames. #[derive(Debug, Default)] -pub struct AirAggregateCtx(Asg, AirStack, Option>); +pub struct AirAggregateCtx { + /// The ASG under construction by this parser. + /// + /// The ASG must be under exclusive ownership of this parser to ensure + /// that graph metadata + /// (e.g. indexes) + /// are accurate. + asg: Asg, + + /// Held parser frames. + stack: AirStack, + + /// The package currently being parsed, + /// if any. + /// + /// This is not necessarily the current compilation unit, + /// as the parser may be parsing imports. + ooi_pkg: Option>, +} /// Limit of the maximum number of held parser frames. /// @@ -387,13 +397,11 @@ impl AirAggregateCtx { } fn stack(&mut self) -> &mut AirStack { - let Self(_, stack, _) = self; - stack + &mut self.stack } fn stack_ref(&self) -> &AirStack { - let Self(_, stack, _) = self; - stack + &self.stack } /// Return control to the parser atop of the stack if `st` is an @@ -474,7 +482,9 @@ impl AirAggregateCtx { start: Span, name: SPair, ) -> Result, AsgError> { - let Self(asg, _, pkg) = self; + let Self { + asg, ooi_pkg: pkg, .. + } = self; let oi_root = asg.root(start); let oi_pkg = asg.create(Pkg::new_canonical(start, name)?); @@ -498,15 +508,12 @@ impl AirAggregateCtx { /// Indicate that there is no longer any active package. fn pkg_clear(&mut self) { - let Self(_, _, pkg) = self; - pkg.take(); + self.ooi_pkg.take(); } /// The active package if any. fn pkg_oi(&self) -> Option> { - match self { - Self(_, _, oi) => *oi, - } + self.ooi_pkg } /// The active container (rooting context) for [`Ident`]s. @@ -518,9 +525,10 @@ impl AirAggregateCtx { /// A value of [`None`] indicates that no bindings are permitted in the /// current context. fn rooting_oi(&self) -> Option> { - let Self(_, stack, _) = self; - - stack.iter().rev().find_map(|st| st.active_rooting_oi()) + self.stack + .iter() + .rev() + .find_map(|st| st.active_rooting_oi()) } /// The active dangling expression context for [`Expr`]s. @@ -530,9 +538,8 @@ impl AirAggregateCtx { /// (and so must be identified). fn dangling_expr_oi(&self) -> Option> { use AirAggregate::*; - let Self(_, stack, _) = self; - stack.iter().rev().find_map(|st| match st { + self.stack.iter().rev().find_map(|st| match st { Uninit => None, // It should never be possible to define expressions directly in @@ -565,9 +572,8 @@ impl AirAggregateCtx { /// permitted in this current context. fn expansion_oi(&self) -> Option> { use AirAggregate::*; - let Self(_, stack, _) = self; - stack.iter().rev().find_map(|st| match st { + self.stack.iter().rev().find_map(|st| match st { Uninit => None, Root(_) => None, Pkg(pkg_st) => pkg_st.active_pkg_oi().map(Into::into), @@ -643,7 +649,7 @@ impl AirAggregateCtx { /// To retrieve the span of a previously declared object, /// you must resolve the [`ObjectIndex`] and inspect it. fn lookup_lexical_or_missing(&mut self, name: SPair) -> ObjectIndex { - let Self(asg, stack, _) = self; + let Self { asg, stack, .. } = self; stack .iter() @@ -656,7 +662,7 @@ impl AirAggregateCtx { /// /// TODO: More information as this is formalized. fn create_env_indexed_ident(&mut self, name: SPair) -> ObjectIndex { - let Self(asg, stack, _) = self; + let Self { asg, stack, .. } = self; let oi_ident = asg.create(Ident::declare(name)); // TODO: This will need the active OI to support `AirIdent`s @@ -802,39 +808,34 @@ impl AsMut for AirAggregateCtx { impl AsRef for AirAggregateCtx { fn as_ref(&self) -> &Asg { - match self { - Self(asg, _, _) => asg, - } + &self.asg } } impl AsMut for AirAggregateCtx { fn as_mut(&mut self) -> &mut Asg { - match self { - Self(asg, _, _) => asg, - } + &mut self.asg } } impl AsMut for AirAggregateCtx { fn as_mut(&mut self) -> &mut AirStack { - match self { - Self(_, stack, _) => stack, - } + &mut self.stack } } impl From for Asg { fn from(ctx: AirAggregateCtx) -> Self { - match ctx { - AirAggregateCtx(asg, _, _) => asg, - } + ctx.asg } } impl From for AirAggregateCtx { fn from(asg: Asg) -> Self { - Self(asg, Default::default(), None) + Self { + asg, + ..Default::default() + } } }