From ebf1de5a60448b1cca939d4b2a838b3021c1727d Mon Sep 17 00:00:00 2001 From: Mike Gerwitz Date: Thu, 19 May 2022 11:17:04 -0400 Subject: [PATCH] tamer: asg::Ident{Object=>}: Rename I think this may have been renamed _from_ `Ident` some time ago, but I'm too lazy to check. In any case, the name is redundant. DEV-11864 --- tamer/benches/asg.rs | 4 +- tamer/src/asg/graph.rs | 30 ++-- tamer/src/asg/ident.rs | 236 ++++++++++++++---------------- tamer/src/asg/mod.rs | 30 ++-- tamer/src/ld/xmle/lower.rs | 14 +- tamer/src/ld/xmle/section.rs | 34 ++--- tamer/src/ld/xmle/xir.rs | 10 +- tamer/src/ld/xmle/xir/test.rs | 58 ++++---- tamer/src/obj/xmlo/asg_builder.rs | 21 ++- 9 files changed, 202 insertions(+), 235 deletions(-) diff --git a/tamer/benches/asg.rs b/tamer/benches/asg.rs index 339f76bb..35526d2d 100644 --- a/tamer/benches/asg.rs +++ b/tamer/benches/asg.rs @@ -308,10 +308,10 @@ mod object { mod ident { use super::*; - use tamer::asg::{IdentKind, IdentObject, Source}; + use tamer::asg::{Ident, IdentKind, Source}; use tamer::sym::GlobalSymbolIntern; - type Sut = IdentObject; + type Sut = Ident; #[bench] fn declare_1_000(bench: &mut Bencher) { diff --git a/tamer/src/asg/graph.rs b/tamer/src/asg/graph.rs index bbb0fed9..d0204d6e 100644 --- a/tamer/src/asg/graph.rs +++ b/tamer/src/asg/graph.rs @@ -20,7 +20,7 @@ //! Abstract graph as the basis for concrete ASGs. use super::{ - AsgError, FragmentText, IdentKind, IdentObject, Source, TransitionResult, + AsgError, FragmentText, Ident, IdentKind, Source, TransitionResult, }; use crate::global; use crate::sym::SymbolId; @@ -44,7 +44,7 @@ pub type AsgEdge = (); /// /// Enclosed in an [`Option`] to permit moving owned values out of the /// graph. -pub type Node = Option; +pub type Node = Option; /// Index size for Graph nodes and edges. type Ix = global::ProgSymSize; @@ -59,7 +59,7 @@ type Ix = global::ProgSymSize; /// /// This IR focuses on the definition and manipulation of objects and their /// dependencies. -/// See [`IdentObject`]for a summary of valid identifier object state +/// See [`Ident`]for a summary of valid identifier object state /// transitions. /// /// Objects are never deleted from the graph, @@ -118,7 +118,7 @@ impl Asg { // Automatically add the root which will be used to determine what // identifiers ought to be retained by the final program. // This is not indexed and is not accessable by name. - let root_node = graph.add_node(Some(IdentObject::Root)); + let root_node = graph.add_node(Some(Ident::Root)); Self { graph, @@ -166,10 +166,10 @@ impl Asg { /// Lookup `ident` or add a missing identifier to the graph and return a /// reference to it. /// - /// See [`IdentObject::declare`] for more information. + /// See [`Ident::declare`] for more information. fn lookup_or_missing(&mut self, ident: SymbolId) -> ObjectRef { self.lookup(ident).unwrap_or_else(|| { - let index = self.graph.add_node(Some(IdentObject::declare(ident))); + let index = self.graph.add_node(Some(Ident::declare(ident))); self.index_identifier(ident, index); ObjectRef::new(index) @@ -191,7 +191,7 @@ impl Asg { f: F, ) -> AsgResult where - F: FnOnce(IdentObject) -> TransitionResult, + F: FnOnce(Ident) -> TransitionResult, { let identi = self.lookup_or_missing(name); self.with_ident(identi, f) @@ -206,7 +206,7 @@ impl Asg { /// value on transition failure. fn with_ident(&mut self, identi: ObjectRef, f: F) -> AsgResult where - F: FnOnce(IdentObject) -> TransitionResult, + F: FnOnce(Ident) -> TransitionResult, { let node = self.graph.node_weight_mut(identi.into()).unwrap(); @@ -274,7 +274,7 @@ impl Asg { /// /// For more information on state transitions that can occur when /// redeclaring an identifier that already exists, - /// see [`IdentObject::resolve`]. + /// see [`Ident::resolve`]. /// /// A successful declaration will add an identifier to the graph /// and return an [`ObjectRef`] reference. @@ -310,8 +310,8 @@ impl Asg { /// on the graph will not be altered. /// Resolution will otherwise fail in error. /// - /// See [`IdentObject::extern_`] and - /// [`IdentObject::resolve`] for more information on + /// See [`Ident::extern_`] and + /// [`Ident::resolve`] for more information on /// compatibility related to extern resolution. pub fn declare_extern( &mut self, @@ -326,7 +326,7 @@ impl Asg { /// /// Fragments are intended for use by the [linker][crate::ld]. /// For more information, - /// see [`IdentObject::set_fragment`]. + /// see [`Ident::set_fragment`]. pub fn set_fragment( &mut self, name: SymbolId, @@ -343,7 +343,7 @@ impl Asg { /// between multiple graphs. /// It is nevertheless wrapped in an [`Option`] just in case. #[inline] - pub fn get>(&self, index: I) -> Option<&IdentObject> { + pub fn get>(&self, index: I) -> Option<&Ident> { self.graph.node_weight(index.into().into()).map(|node| { node.as_ref() .expect("internal error: Asg::get missing Node data") @@ -396,7 +396,7 @@ impl Asg { /// a missing identifier will be added as a placeholder, /// allowing the ASG to be built with partial information as /// identifiers continue to be discovered. - /// See [`IdentObject::declare`] for more information. + /// See [`Ident::declare`] for more information. /// /// References to both identifiers are returned in argument order. pub fn add_dep_lookup( @@ -416,7 +416,7 @@ impl Asg { /// Reference to an [object][super::object] stored within the [`Asg`]. /// -/// IdentObject references are integer offsets, +/// Ident references are integer offsets, /// not pointers. /// See the [module-level documentation][self] for more information. #[derive(Debug, Copy, Clone, Default, PartialEq, Eq)] diff --git a/tamer/src/asg/ident.rs b/tamer/src/asg/ident.rs index bbdcd690..bbd5f143 100644 --- a/tamer/src/asg/ident.rs +++ b/tamer/src/asg/ident.rs @@ -37,7 +37,7 @@ pub type TransitionResult = Result; /// `--------------------` `-----------' /// ``` #[derive(Debug, PartialEq, Clone)] -pub enum IdentObject { +pub enum Ident { /// An identifier is expected to be defined but is not yet available. /// /// This variant contains the symbol representing the name of the @@ -55,7 +55,7 @@ pub enum IdentObject { /// An identifier that has not yet been resolved. /// - /// Externs are upgraded to [`IdentObject::Ident`] once an identifier of + /// Externs are upgraded to [`Ident::Ident`] once an identifier of /// the same name is loaded. /// It is an error if the loaded identifier does not have a compatible /// [`IdentKind`]. @@ -89,7 +89,7 @@ pub enum IdentObject { Root, } -impl IdentObject { +impl Ident { /// Identifier name. pub fn name(&self) -> SymbolId { match self { @@ -101,14 +101,14 @@ impl IdentObject { // This should never be called, // and can go away when we can stop pretending that the root // is an identifier. - Self::Root => unimplemented!("IdentObject::name for Root"), + Self::Root => unimplemented!("Ident::name for Root"), } } /// Identifier [`IdentKind`]. /// /// If the object does not have a kind - /// (as is the case with [`IdentObject::Missing`]), + /// (as is the case with [`Ident::Missing`]), /// [`None`] is returned. pub fn kind(&self) -> Option<&IdentKind> { match self { @@ -125,7 +125,7 @@ impl IdentObject { /// Identifier [`Source`]. /// /// If the object does not have source information - /// (as is the case with [`IdentObject::Extern`]), + /// (as is the case with [`Ident::Extern`]), /// [`None`] is returned. pub fn src(&self) -> Option<&Source> { match self { @@ -156,22 +156,22 @@ impl IdentObject { /// /// This is the base state for all identifiers. pub fn declare(ident: SymbolId) -> Self { - IdentObject::Missing(ident) + Ident::Missing(ident) } /// Attempt to redeclare an identifier with additional information. /// - /// If an existing identifier is an [`IdentObject::Extern`], + /// If an existing identifier is an [`Ident::Extern`], /// then the declaration will be compared just the same, /// but the identifier will be converted from an extern into an /// identifier. /// When this happens, /// the extern is said to be _resolved_. /// - /// If a virtual identifier of type [`IdentObject::IdentFragment`] is + /// If a virtual identifier of type [`Ident::IdentFragment`] is /// overridden, /// then its fragment is cleared - /// (it returns to a [`IdentObject::Ident`]) + /// (it returns to a [`Ident::Ident`]) /// to make way for the fragment of the override. /// /// Overrides will always have their virtual flag cleared, @@ -191,15 +191,12 @@ impl IdentObject { self, kind: IdentKind, mut src: Source, - ) -> TransitionResult { + ) -> TransitionResult { match self { - IdentObject::Ident(name, ref orig_kind, ref orig_src) - | IdentObject::IdentFragment( - name, - ref orig_kind, - ref orig_src, - _, - ) if src.override_ => { + Ident::Ident(name, ref orig_kind, ref orig_src) + | Ident::IdentFragment(name, ref orig_kind, ref orig_src, _) + if src.override_ => + { if !orig_src.virtual_ { let err = TransitionError::NonVirtualOverride { name: name }; @@ -224,15 +221,13 @@ impl IdentObject { src.virtual_ = false; // Note that this has the effect of clearing fragments if we - // originally were in state `IdentObject::IdentFragment`. - Ok(IdentObject::Ident(name, kind, src)) + // originally were in state `Ident::IdentFragment`. + Ok(Ident::Ident(name, kind, src)) } // If we encountered the override _first_, flip the context by // declaring a new identifier and trying to override that. - IdentObject::Ident(name, orig_kind, orig_src) - if orig_src.override_ => - { + Ident::Ident(name, orig_kind, orig_src) if orig_src.override_ => { Self::declare(name) .resolve(kind, src)? .resolve(orig_kind, orig_src) @@ -240,17 +235,16 @@ impl IdentObject { // Same as above, but for fragments, we want to keep the // _original override_ fragment. - IdentObject::IdentFragment( - name, - orig_kind, - orig_src, - orig_text, - ) if orig_src.override_ => Self::declare(name) - .resolve(kind, src)? - .resolve(orig_kind, orig_src)? - .set_fragment(orig_text), + Ident::IdentFragment(name, orig_kind, orig_src, orig_text) + if orig_src.override_ => + { + Self::declare(name) + .resolve(kind, src)? + .resolve(orig_kind, orig_src)? + .set_fragment(orig_text) + } - IdentObject::Extern(name, ref orig_kind, _) => { + Ident::Extern(name, ref orig_kind, _) => { if orig_kind != &kind { let err = TransitionError::ExternResolution { name: name, @@ -261,12 +255,12 @@ impl IdentObject { return Err((self, err)); } - Ok(IdentObject::Ident(name, kind, src)) + Ok(Ident::Ident(name, kind, src)) } // These represent the prolog and epilogue of maps. This // situation will be resolved in the future. - IdentObject::IdentFragment( + Ident::IdentFragment( _, IdentKind::MapHead | IdentKind::MapTail @@ -275,9 +269,7 @@ impl IdentObject { .., ) => Ok(self), - IdentObject::Missing(name) => { - Ok(IdentObject::Ident(name, kind, src)) - } + Ident::Missing(name) => Ok(Ident::Ident(name, kind, src)), _ => { let err = TransitionError::Redeclare { name: self.name() }; @@ -300,15 +292,15 @@ impl IdentObject { /// this accepts and returns a reference to the identifier. /// /// At present, - /// both [`IdentObject::Missing`] and [`IdentObject::Extern`] are + /// both [`Ident::Missing`] and [`Ident::Extern`] are /// considered to be unresolved. - pub fn resolved(&self) -> Result<&IdentObject, UnresolvedError> { + pub fn resolved(&self) -> Result<&Ident, UnresolvedError> { match self { - IdentObject::Missing(name) => { + Ident::Missing(name) => { Err(UnresolvedError::Missing { name: *name }) } - IdentObject::Extern(name, ref kind, ref src) => { + Ident::Extern(name, ref kind, ref src) => { Err(UnresolvedError::Extern { name: *name, kind: kind.clone(), @@ -316,11 +308,11 @@ impl IdentObject { }) } - IdentObject::Ident(..) | IdentObject::IdentFragment(..) => Ok(self), + Ident::Ident(..) | Ident::IdentFragment(..) => Ok(self), // This should never be called. - IdentObject::Root => { - unimplemented!("IdentObject::resolved on Root") + Ident::Root => { + unimplemented!("Ident::resolved on Root") } } } @@ -337,16 +329,16 @@ impl IdentObject { /// or my represent a duplicate (but compatible) extern /// declaration. /// - /// If no kind is assigned (such as [`IdentObject::Missing`]), + /// If no kind is assigned (such as [`Ident::Missing`]), /// then a new extern is produced. - /// See for example [`IdentObject::Extern`]. + /// See for example [`Ident::Extern`]. pub fn extern_( self, kind: IdentKind, src: Source, - ) -> TransitionResult { + ) -> TransitionResult { match self.kind() { - None => Ok(IdentObject::Extern(self.name(), kind, src)), + None => Ok(Ident::Extern(self.name(), kind, src)), Some(cur_kind) => { if cur_kind != &kind { let err = TransitionError::ExternResolution { @@ -372,13 +364,10 @@ impl IdentObject { /// Note, however, that an identifier's fragment may be cleared under /// certain circumstances (such as symbol overrides), /// making way for a new fragment to be set. - pub fn set_fragment( - self, - text: FragmentText, - ) -> TransitionResult { + pub fn set_fragment(self, text: FragmentText) -> TransitionResult { match self { - IdentObject::Ident(sym, kind, src) => { - Ok(IdentObject::IdentFragment(sym, kind, src, text)) + Ident::Ident(sym, kind, src) => { + Ok(Ident::IdentFragment(sym, kind, src, text)) } // If we get to this point in a properly functioning program (at @@ -390,13 +379,13 @@ impl IdentObject { // If this is not permissable, then we should have already // prevented the `resolve` transition before this fragment was // encountered. - IdentObject::IdentFragment(_, _, ref src, ..) if src.override_ => { + Ident::IdentFragment(_, _, ref src, ..) if src.override_ => { Ok(self) } // These represent the prolog and epilogue of maps. This // situation will be resolved in the future. - IdentObject::IdentFragment( + Ident::IdentFragment( _, IdentKind::MapHead | IdentKind::MapTail @@ -406,10 +395,8 @@ impl IdentObject { ) => Ok(self), _ => { - let msg = format!( - "identifier is not a IdentObject::Ident): {:?}", - self, - ); + let msg = + format!("identifier is not a Ident::Ident): {:?}", self,); Err((self, TransitionError::BadFragmentDest { name: msg })) } @@ -417,7 +404,7 @@ impl IdentObject { } } -/// An error attempting to transition from one [`IdentObject`] state to +/// An error attempting to transition from one [`Ident`] state to /// another. #[derive(Clone, Debug, PartialEq)] pub enum TransitionError { @@ -449,7 +436,7 @@ pub enum TransitionError { /// The provided identifier is not in a state that is permitted to /// receive a fragment. /// - /// See [`IdentObject::set_fragment`]. + /// See [`Ident::set_fragment`]. BadFragmentDest { name: String }, } @@ -828,26 +815,26 @@ mod test { use crate::num::Dim; use crate::sym::{GlobalSymbolIntern, SymbolId}; - // Note that IdentObject has no variants capable of None + // Note that Ident has no variants capable of None #[test] fn ident_object_name() { let sym: SymbolId = "sym".intern(); - assert_eq!(sym, IdentObject::Missing(sym).name()); + assert_eq!(sym, Ident::Missing(sym).name()); assert_eq!( sym, - IdentObject::Ident(sym, IdentKind::Meta, Source::default()).name() + Ident::Ident(sym, IdentKind::Meta, Source::default()).name() ); assert_eq!( sym, - IdentObject::Extern(sym, IdentKind::Meta, Source::default()).name() + Ident::Extern(sym, IdentKind::Meta, Source::default()).name() ); assert_eq!( sym, - IdentObject::IdentFragment( + Ident::IdentFragment( sym, IdentKind::Meta, Source::default(), @@ -862,21 +849,21 @@ mod test { let sym: SymbolId = "sym".intern(); let kind = IdentKind::Class(Dim::Matrix); - assert_eq!(None, IdentObject::Missing(sym).kind()); + assert_eq!(None, Ident::Missing(sym).kind()); assert_eq!( Some(&kind), - IdentObject::Ident(sym, kind.clone(), Source::default()).kind() + Ident::Ident(sym, kind.clone(), Source::default()).kind() ); assert_eq!( Some(&kind), - IdentObject::Extern(sym, kind.clone(), Source::default()).kind() + Ident::Extern(sym, kind.clone(), Source::default()).kind() ); assert_eq!( Some(&kind), - IdentObject::IdentFragment( + Ident::IdentFragment( sym, kind.clone(), Source::default(), @@ -894,21 +881,21 @@ mod test { ..Default::default() }; - assert_eq!(None, IdentObject::Missing(sym).src()); + assert_eq!(None, Ident::Missing(sym).src()); assert_eq!( Some(&src), - IdentObject::Ident(sym, IdentKind::Meta, src.clone()).src() + Ident::Ident(sym, IdentKind::Meta, src.clone()).src() ); assert_eq!( None, - IdentObject::Extern(sym, IdentKind::Meta, src.clone()).src() + Ident::Extern(sym, IdentKind::Meta, src.clone()).src() ); assert_eq!( Some(&src), - IdentObject::IdentFragment( + Ident::IdentFragment( sym, IdentKind::Meta, src.clone(), @@ -923,23 +910,21 @@ mod test { let sym: SymbolId = "sym".intern(); let text = "foo".into(); - assert_eq!(None, IdentObject::Missing(sym).fragment()); + assert_eq!(None, Ident::Missing(sym).fragment()); assert_eq!( None, - IdentObject::Ident(sym, IdentKind::Meta, Source::default()) - .fragment() + Ident::Ident(sym, IdentKind::Meta, Source::default()).fragment() ); assert_eq!( None, - IdentObject::Extern(sym, IdentKind::Meta, Source::default()) - .fragment() + Ident::Extern(sym, IdentKind::Meta, Source::default()).fragment() ); assert_eq!( Some(text), - IdentObject::IdentFragment( + Ident::IdentFragment( sym, IdentKind::Meta, Source::default(), @@ -952,14 +937,14 @@ mod test { #[test] fn ident_object_missing() { let sym: SymbolId = "missing".intern(); - assert_eq!(IdentObject::Missing(sym), IdentObject::declare(sym)); + assert_eq!(Ident::Missing(sym), Ident::declare(sym)); } #[test] fn resolved_on_missing() { let sym: SymbolId = "missing".intern(); - let result = IdentObject::declare(sym) + let result = Ident::declare(sym) .resolved() .expect_err("expected error asserting resolved() on missing"); @@ -981,8 +966,8 @@ mod test { }; assert_eq!( - IdentObject::Ident(sym, kind.clone(), src.clone()), - IdentObject::declare(sym) + Ident::Ident(sym, kind.clone(), src.clone()), + Ident::declare(sym) .resolve(kind.clone(), src.clone()) .unwrap(), ); @@ -998,8 +983,8 @@ mod test { }; assert_eq!( - &IdentObject::Ident(sym, kind.clone(), src.clone()), - IdentObject::declare(sym) + &Ident::Ident(sym, kind.clone(), src.clone()), + Ident::declare(sym) .resolve(kind.clone(), src.clone()) .unwrap() .resolved() @@ -1017,7 +1002,7 @@ mod test { let kind = IdentKind::Meta; let src = Source::default(); - let first = IdentObject::declare(sym) + let first = Ident::declare(sym) .resolve(kind.clone(), src.clone()) .unwrap(); @@ -1051,8 +1036,8 @@ mod test { }; assert_eq!( - Ok(IdentObject::Extern(sym, kind.clone(), src.clone())), - IdentObject::declare(sym).extern_(kind, src), + Ok(Ident::Extern(sym, kind.clone(), src.clone())), + Ident::declare(sym).extern_(kind, src), ); } @@ -1067,7 +1052,7 @@ mod test { ..Default::default() }; - let result = IdentObject::Extern(sym, kind.clone(), src.clone()) + let result = Ident::Extern(sym, kind.clone(), src.clone()) .resolved() .expect_err("expected error asserting resolved() on extern"); @@ -1130,11 +1115,11 @@ mod test { }; // Compatible kind, should resolve. - let result = IdentObject::declare(sym) + let result = Ident::declare(sym) .extern_(kind.clone(), Source::default()) .and_then(|o| o.resolve(kind.clone(), src.clone())); - assert_eq!(Ok(IdentObject::Ident(sym, kind, src)), result,); + assert_eq!(Ok(Ident::Ident(sym, kind, src)), result,); } // Identifier first, then extern @@ -1148,11 +1133,11 @@ mod test { }; // Compatible kind, should resolve. - let result = IdentObject::declare(sym) + let result = Ident::declare(sym) .resolve(kind.clone(), src.clone()) .and_then(|o| o.extern_(kind.clone(), Source::default())); - assert_eq!(Ok(IdentObject::Ident(sym, kind, src)), result,); + assert_eq!(Ok(Ident::Ident(sym, kind, src)), result,); } #[test] @@ -1168,13 +1153,13 @@ mod test { ..Default::default() }; - let result = IdentObject::declare(sym) + let result = Ident::declare(sym) .extern_(kind.clone(), src_first.clone()) .and_then(|o| o.extern_(kind.clone(), src_second)); // Note that, if it resolves, it should keep what is // _existing_, meaning that it must keep the first src. - assert_eq!(Ok(IdentObject::Extern(sym, kind, src_first)), result); + assert_eq!(Ok(Ident::Extern(sym, kind, src_first)), result); } // Extern first, then identifier @@ -1187,7 +1172,7 @@ mod test { ..Default::default() }; - let orig = IdentObject::declare(sym) + let orig = Ident::declare(sym) .extern_(kind.clone(), Source::default()) .unwrap(); @@ -1231,7 +1216,7 @@ mod test { ..Default::default() }; - let orig = IdentObject::declare(sym) + let orig = Ident::declare(sym) .resolve(kind_given.clone(), src.clone()) .unwrap(); @@ -1276,14 +1261,14 @@ mod test { }; let kind = IdentKind::Meta; - let ident = IdentObject::declare(sym) + let ident = Ident::declare(sym) .resolve(kind.clone(), src.clone()) .unwrap(); let text = FragmentText::from("a fragment"); let ident_with_frag = ident.set_fragment(text.clone()); assert_eq!( - Ok(IdentObject::IdentFragment(sym, kind, src, text)), + Ok(Ident::IdentFragment(sym, kind, src, text)), ident_with_frag, ); } @@ -1297,14 +1282,14 @@ mod test { }; let kind = IdentKind::Meta; - let ident = IdentObject::declare(sym) + let ident = Ident::declare(sym) .resolve(kind.clone(), src.clone()) .unwrap(); let text = FragmentText::from("a fragment for resolved()"); let ident_with_frag = ident.set_fragment(text.clone()); assert_eq!( - Ok(&IdentObject::IdentFragment(sym, kind, src, text)), + Ok(&Ident::IdentFragment(sym, kind, src, text)), ident_with_frag.unwrap().resolved(), ); } @@ -1312,7 +1297,7 @@ mod test { #[test] fn add_fragment_to_fragment_fails() { let sym: SymbolId = "badsym".intern(); - let ident = IdentObject::declare(sym) + let ident = Ident::declare(sym) .resolve(IdentKind::Meta, Source::default()) .unwrap(); @@ -1343,7 +1328,7 @@ mod test { let over_src = "src".intern(); let kind = IdentKind::Meta; - let virt = IdentObject::declare(sym) + let virt = Ident::declare(sym) .resolve( kind.clone(), Source { @@ -1369,7 +1354,7 @@ mod test { ..over_src }; - assert_eq!(Ok(IdentObject::Ident(sym, kind, expected_src)), result); + assert_eq!(Ok(Ident::Ident(sym, kind, expected_src)), result); } // Override is encountered before the virtual @@ -1385,7 +1370,7 @@ mod test { ..Default::default() }; - let over = IdentObject::declare(sym) + let over = Ident::declare(sym) .resolve(kind.clone(), over_src.clone()) .unwrap(); @@ -1405,7 +1390,7 @@ mod test { ..over_src }; - assert_eq!(Ok(IdentObject::Ident(sym, kind, expected_src)), result); + assert_eq!(Ok(Ident::Ident(sym, kind, expected_src)), result); } #[test] @@ -1413,7 +1398,7 @@ mod test { let sym: SymbolId = "non_virtual".intern(); let kind = IdentKind::Meta; - let non_virt = IdentObject::declare(sym) + let non_virt = Ident::declare(sym) .resolve( kind.clone(), Source { @@ -1468,7 +1453,7 @@ mod test { let src_sym: SymbolId = "src".intern(); let kind = IdentKind::Meta; - let virt = IdentObject::declare(sym) + let virt = Ident::declare(sym) .resolve( kind.clone(), Source { @@ -1541,7 +1526,7 @@ mod test { ..Default::default() }; - let over = IdentObject::declare(sym) + let over = Ident::declare(sym) .resolve(kind.clone(), over_src.clone()) .unwrap(); @@ -1551,7 +1536,7 @@ mod test { let over_frag = over.set_fragment(text.clone()); assert_eq!( - Ok(IdentObject::IdentFragment( + Ok(Ident::IdentFragment( sym, kind.clone(), over_src.clone(), @@ -1567,7 +1552,7 @@ mod test { // the override was encountered _first_, so we want to keep // its fragment. assert_eq!( - Ok(IdentObject::IdentFragment( + Ok(Ident::IdentFragment( sym, kind.clone(), over_src.clone(), @@ -1582,7 +1567,7 @@ mod test { // that encountering it will not cause an error, because we // still have an IdentFragment at this point. assert_eq!( - Ok(IdentObject::IdentFragment( + Ok(Ident::IdentFragment( sym, kind, over_src.clone(), @@ -1606,19 +1591,14 @@ mod test { ..Default::default() }; - let virt = IdentObject::declare(sym) + let virt = Ident::declare(sym) .resolve(kind.clone(), virt_src.clone()) .unwrap(); let text = FragmentText::from("remove me"); let virt_frag = virt.set_fragment(text.clone()); assert_eq!( - Ok(IdentObject::IdentFragment( - sym, - kind.clone(), - virt_src, - text - )), + Ok(Ident::IdentFragment(sym, kind.clone(), virt_src, text)), virt_frag, ); @@ -1634,8 +1614,8 @@ mod test { // The act of overriding the object should have cleared any // existing fragment, making way for a new fragment to take its // place as soon as it is discovered. (So, back to an - // IdentObject::Ident.) - assert_eq!(Ok(IdentObject::Ident(sym, kind, over_src)), result); + // Ident::Ident.) + assert_eq!(Ok(Ident::Ident(sym, kind, over_src)), result); } #[test] @@ -1649,7 +1629,7 @@ mod test { ..Default::default() }; - let virt = IdentObject::declare(sym) + let virt = Ident::declare(sym) .resolve(kind.clone(), virt_src.clone()) .unwrap(); let virt_frag = virt.set_fragment("".into()).unwrap(); @@ -1704,15 +1684,13 @@ mod test { ..Default::default() }; - let obj = IdentObject::declare(sym) - .resolve(given, src.clone()) - .unwrap(); + let obj = Ident::declare(sym).resolve(given, src.clone()).unwrap(); let fragment = "a fragment".intern(); let obj_with_frag = obj.set_fragment(fragment); assert_eq!( - Ok(IdentObject::IdentFragment(sym, expected, src, fragment)), + Ok(Ident::IdentFragment(sym, expected, src, fragment)), obj_with_frag, ); } diff --git a/tamer/src/asg/mod.rs b/tamer/src/asg/mod.rs index 3b916549..951f8e9a 100644 --- a/tamer/src/asg/mod.rs +++ b/tamer/src/asg/mod.rs @@ -37,7 +37,7 @@ //! //! Graph Structure //! =============== -//! Each node (vector) in the graph represents an [object][IdentObject], +//! Each node (vector) in the graph represents an [object][Ident], //! such as an identifier or an expression. //! Each directed edge `(A->B)` represents that `A` depends upon `B`. //! @@ -51,7 +51,7 @@ //! [scc]: https://en.wikipedia.org/wiki/Strongly_connected_component //! //! Each object may have a number of valid states; -//! see [`IdentObject`] for valid object states and transitions. +//! see [`Ident`] for valid object states and transitions. //! //! //! How To Use @@ -61,7 +61,7 @@ //! //! ``` //! use tamer::global; -//! use tamer::asg::{DefaultAsg, IdentKind, IdentObject, Source}; +//! use tamer::asg::{DefaultAsg, IdentKind, Ident, Source}; //! use tamer::sym::{Interner, DefaultProgInterner}; //! //! # fn main() -> Result<(), Box> { @@ -80,7 +80,7 @@ //! let identb = asg.declare_extern(identb_sym, IdentKind::Meta, Source::default())?; //! //! assert_eq!( -//! Some(&IdentObject::Extern(identb_sym, IdentKind::Meta, Source::default())), +//! Some(&Ident::Extern(identb_sym, IdentKind::Meta, Source::default())), //! asg.get(identb), //! ); //! @@ -105,12 +105,12 @@ //! it is often the case that a dependency will have to be added to the //! graph before it is resolved. //! For example, -//! [`Asg::add_dep_lookup`] will add an [`IdentObject::Missing`] to the graph +//! [`Asg::add_dep_lookup`] will add an [`Ident::Missing`] to the graph //! if either identifier has not yet been declared. //! //! ``` //! # use tamer::global; -//! # use tamer::asg::{DefaultAsg, IdentKind, IdentObject, FragmentText, Source}; +//! # use tamer::asg::{DefaultAsg, IdentKind, Ident, FragmentText, Source}; //! # use tamer::sym::{Interner, DefaultProgInterner}; //! # //! # fn main() -> Result<(), Box> { @@ -124,8 +124,8 @@ //! let identb_sym = interner.intern("identb"); //! let (identa, identb) = asg.add_dep_lookup(identa_sym, identb_sym); //! -//! assert_eq!(Some(&IdentObject::Missing(identa_sym)), asg.get(identa)); -//! assert_eq!(Some(&IdentObject::Missing(identb_sym)), asg.get(identb)); +//! assert_eq!(Some(&Ident::Missing(identa_sym)), asg.get(identa)); +//! assert_eq!(Some(&Ident::Missing(identb_sym)), asg.get(identb)); //! //! // The identifiers returned above are proper objects on the graph. //! assert_eq!(Some(identa), asg.lookup(identa_sym)); @@ -136,7 +136,7 @@ //! asg.declare(identa_sym, IdentKind::Meta, Source::default())?; //! //! assert_eq!( -//! Some(&IdentObject::Ident(identa_sym, IdentKind::Meta, Source::default())), +//! Some(&Ident::Ident(identa_sym, IdentKind::Meta, Source::default())), //! asg.get(identa), //! ); //! @@ -149,14 +149,14 @@ //! Fragments //! --------- //! A compiled fragment can be attached to any resolved identifier (see -//! [`IdentObject::Ident`]) using [`Asg::set_fragment`]. -//! Doing so changes the state of the identifier to [`IdentObject::IdentFragment`], +//! [`Ident::Ident`]) using [`Asg::set_fragment`]. +//! Doing so changes the state of the identifier to [`Ident::IdentFragment`], //! and it is an error to attempt to overwrite that fragment once it is //! set. //! //! ``` //! # use tamer::global; -//! # use tamer::asg::{DefaultAsg, IdentKind, IdentObject, FragmentText, Source}; +//! # use tamer::asg::{DefaultAsg, IdentKind, Ident, FragmentText, Source}; //! # use tamer::sym::{Interner, GlobalSymbolIntern}; //! # //! # fn main() -> Result<(), Box> { @@ -174,7 +174,7 @@ //! asg.set_fragment(sym, FragmentText::from("test fragment"))?; //! //! assert_eq!( -//! Some(&IdentObject::IdentFragment( +//! Some(&Ident::IdentFragment( //! sym, //! IdentKind::Meta, //! Source::default(), @@ -199,8 +199,8 @@ mod object; pub use error::AsgError; pub use graph::{Asg, AsgResult, IndexType, ObjectRef}; pub use ident::{ - FragmentText, IdentKind, IdentObject, Source, TransitionError, - TransitionResult, UnresolvedError, + FragmentText, Ident, IdentKind, Source, TransitionError, TransitionResult, + UnresolvedError, }; /// Default concrete ASG implementation. diff --git a/tamer/src/ld/xmle/lower.rs b/tamer/src/ld/xmle/lower.rs index 477bd59b..2f37833c 100644 --- a/tamer/src/ld/xmle/lower.rs +++ b/tamer/src/ld/xmle/lower.rs @@ -23,7 +23,7 @@ use super::section::{SectionsError, XmleSections}; use crate::{ - asg::{Asg, IdentKind, IdentObject, ObjectRef}, + asg::{Asg, Ident, IdentKind, ObjectRef}, sym::{st, GlobalSymbolResolve, SymbolId}, }; use petgraph::visit::DfsPostOrder; @@ -64,7 +64,7 @@ where Ok(dest) } -fn get_ident<'a, S>(depgraph: &'a Asg, name: S) -> &'a IdentObject +fn get_ident<'a, S>(depgraph: &'a Asg, name: S) -> &'a Ident where S: Into, { @@ -169,7 +169,7 @@ impl std::error::Error for SortError { mod test { use super::*; use crate::{ - asg::{FragmentText, IdentObject, Source}, + asg::{FragmentText, Ident, Source}, ld::xmle::{section::PushResult, Sections}, num::{Dim, Dtype}, sym::GlobalSymbolIntern, @@ -217,16 +217,16 @@ mod test { // We care only about the order of pushes, not the sections they end // up in. struct StubSections<'a> { - pushed: Vec<&'a IdentObject>, + pushed: Vec<&'a Ident>, } impl<'a> XmleSections<'a> for StubSections<'a> { - fn push(&mut self, ident: &'a IdentObject) -> PushResult { + fn push(&mut self, ident: &'a Ident) -> PushResult { self.pushed.push(ident); Ok(()) } - fn take_deps(&mut self) -> Vec<&'a IdentObject> { + fn take_deps(&mut self) -> Vec<&'a Ident> { unimplemented!() } @@ -286,7 +286,7 @@ mod test { // TODO: This will go away once Root is no longer considered // an identifier. // The real Sections filters this out. - Some(&IdentObject::Root), + Some(&Ident::Root), // Static tail asg.lookup(st::L_MAP_UUUTAIL.into()) .and_then(|id| asg.get(id)), diff --git a/tamer/src/ld/xmle/section.rs b/tamer/src/ld/xmle/section.rs index f441fb5b..cff30754 100644 --- a/tamer/src/ld/xmle/section.rs +++ b/tamer/src/ld/xmle/section.rs @@ -26,7 +26,7 @@ //! which places the relocatable object code fragments in the order //! necessary for execution. -use crate::asg::{IdentKind, IdentObject, UnresolvedError}; +use crate::asg::{Ident, IdentKind, UnresolvedError}; use crate::sym::SymbolId; use fxhash::FxHashSet; use std::mem::take; @@ -44,12 +44,12 @@ pub trait XmleSections<'a> { /// Objects are expected to be properly sorted relative to their order /// of execution so that their text fragments are placed in the /// correct order in the final program text. - fn push(&mut self, ident: &'a IdentObject) -> PushResult; + fn push(&mut self, ident: &'a Ident) -> PushResult; /// Take the list of objects present in the linked file. /// /// The order of these objects does not matter. - fn take_deps(&mut self) -> Vec<&'a IdentObject>; + fn take_deps(&mut self) -> Vec<&'a Ident>; /// Take the ordered text fragments for the `map` section. fn take_map(&mut self) -> Vec; @@ -76,7 +76,7 @@ pub struct Sections<'a> { /// List of objects present in the linked file. /// /// The order of these objects does not matter. - deps: Vec<&'a IdentObject>, + deps: Vec<&'a Ident>, /// External identifiers mapped into this system. map_froms: FxHashSet, @@ -105,9 +105,9 @@ impl<'a> Sections<'a> { } impl<'a> XmleSections<'a> for Sections<'a> { - fn push(&mut self, ident: &'a IdentObject) -> PushResult { + fn push(&mut self, ident: &'a Ident) -> PushResult { // TODO: This can go away once we stop treating root as an ident - if matches!(ident, IdentObject::Root) { + if matches!(ident, Ident::Root) { return Ok(()); } @@ -165,7 +165,7 @@ impl<'a> XmleSections<'a> for Sections<'a> { } #[inline] - fn take_deps(&mut self) -> Vec<&'a IdentObject> { + fn take_deps(&mut self) -> Vec<&'a Ident> { take(&mut self.deps) } @@ -264,7 +264,7 @@ impl std::fmt::Display for SectionsError { #[cfg(test)] mod test { use super::*; - use crate::asg::{IdentKind, IdentObject, Source}; + use crate::asg::{Ident, IdentKind, Source}; use crate::num::{Dim, Dtype}; use crate::sym::GlobalSymbolIntern; @@ -286,7 +286,7 @@ mod test { fn sections_push_adds_dep() -> PushResult { let mut sut = Sut::new(); - let a = IdentObject::IdentFragment( + let a = Ident::IdentFragment( "a".intern(), IdentKind::Const(Dim::Scalar, Dtype::Integer), Default::default(), @@ -294,7 +294,7 @@ mod test { ); // Different section than a, to be sure that we still add it. - let b = IdentObject::IdentFragment( + let b = Ident::IdentFragment( "b".intern(), IdentKind::MapHead, Default::default(), @@ -315,7 +315,7 @@ mod test { fn push_ignores_root() { let mut sut = Sut::new(); - sut.push(&IdentObject::Root).unwrap(); + sut.push(&Ident::Root).unwrap(); assert!(sut.take_deps().is_empty()); } @@ -325,19 +325,19 @@ mod test { fn idents_not_needing_fragments() -> PushResult { let mut sut = Sut::new(); - let cgen = IdentObject::Ident( + let cgen = Ident::Ident( "cgen".intern(), IdentKind::Cgen(Dim::Vector), Default::default(), ); - let gen = IdentObject::Ident( + let gen = Ident::Ident( "gen".intern(), IdentKind::Gen(Dim::Vector, Dtype::Integer), Default::default(), ); - let lparam = IdentObject::Ident( + let lparam = Ident::Ident( "lparam".intern(), IdentKind::Lparam(Dim::Vector, Dtype::Integer), Default::default(), @@ -365,7 +365,7 @@ mod test { let mut sut_a = Sections::new(); let mut sut_b = Sections::new(); - let a = IdentObject::IdentFragment( + let a = Ident::IdentFragment( "a".intern(), IdentKind::Map, Source { @@ -375,7 +375,7 @@ mod test { "mapa".intern(), ); - let b = IdentObject::IdentFragment( + let b = Ident::IdentFragment( "a".intern(), IdentKind::Map, Source { @@ -409,7 +409,7 @@ mod test { macro_rules! add_syms { ($sut:ident, { $($name:ident: $kind:expr,)* }) => { $( - let $name = IdentObject::IdentFragment( + let $name = Ident::IdentFragment( stringify!($name).intern(), $kind, Default::default(), diff --git a/tamer/src/ld/xmle/xir.rs b/tamer/src/ld/xmle/xir.rs index c17a6a92..4c077c59 100644 --- a/tamer/src/ld/xmle/xir.rs +++ b/tamer/src/ld/xmle/xir.rs @@ -31,7 +31,7 @@ use super::{super::LSPAN, section::XmleSections}; use crate::{ - asg::{IdentKind, IdentObject}, + asg::{Ident, IdentKind}, sym::{st::*, SymbolId}, xir::{ iter::{elem_wrap, ElemWrapIter}, @@ -113,7 +113,7 @@ const DEP_TOK_SIZE: usize = DEP_MAX_ATTRS_KEY_VAL + DEP_CLOSE; /// This repeats until no more section object data is available. struct DepListIter<'a> { /// Source data to lower into `l:deps`. - iter: vec::IntoIter<&'a IdentObject>, + iter: vec::IntoIter<&'a Ident>, /// Constant-size [`Token`] buffer used as a stack. toks: ArrayVec, /// Relative path to project root. @@ -122,7 +122,7 @@ struct DepListIter<'a> { impl<'a> DepListIter<'a> { #[inline] - fn new(iter: vec::IntoIter<&'a IdentObject>, relroot: SymbolId) -> Self { + fn new(iter: vec::IntoIter<&'a Ident>, relroot: SymbolId) -> Self { Self { iter, toks: ArrayVec::new(), @@ -144,8 +144,8 @@ impl<'a> DepListIter<'a> { // TODO: re-order sensibly once we're done. self.iter.next().map(|obj| { match obj { - IdentObject::Ident(sym, kind, src) - | IdentObject::IdentFragment(sym, kind, src, _) => (*sym, kind, src), + Ident::Ident(sym, kind, src) + | Ident::IdentFragment(sym, kind, src, _) => (*sym, kind, src), _ => unreachable!( "identifier should have been filtered out during sorting: {:?}", obj, diff --git a/tamer/src/ld/xmle/xir/test.rs b/tamer/src/ld/xmle/xir/test.rs index 8548538e..8d3cdd74 100644 --- a/tamer/src/ld/xmle/xir/test.rs +++ b/tamer/src/ld/xmle/xir/test.rs @@ -78,7 +78,7 @@ fn test_writes_deps() -> TestResult { let relroot = "relroot-deps".intern(); let objs = [ - IdentObject::Ident( + Ident::Ident( "cgentest".intern(), IdentKind::Cgen(Dim::Vector), Source { @@ -89,82 +89,74 @@ fn test_writes_deps() -> TestResult { ..Default::default() }, ), - IdentObject::Ident( + Ident::Ident( "classtest".intern(), IdentKind::Class(Dim::Matrix), Default::default(), ), - IdentObject::Ident( + Ident::Ident( "consttest".intern(), IdentKind::Const(Dim::Scalar, Dtype::Boolean), Default::default(), ), - IdentObject::Ident( + Ident::Ident( "functest".intern(), IdentKind::Func(Dim::Matrix, Dtype::Integer), Default::default(), ), - IdentObject::Ident( + Ident::Ident( "gentest".intern(), IdentKind::Gen(Dim::Matrix, Dtype::Boolean), Default::default(), ), - IdentObject::Ident( + Ident::Ident( "lparamtest".intern(), IdentKind::Gen(Dim::Matrix, Dtype::Float), Default::default(), ), - IdentObject::Ident( + Ident::Ident( "paramtest".intern(), IdentKind::Gen(Dim::Scalar, Dtype::Integer), Default::default(), ), - IdentObject::Ident( + Ident::Ident( "ratetest".intern(), IdentKind::Rate(Dtype::Integer), Default::default(), ), - IdentObject::Ident( - "tpltest".intern(), - IdentKind::Tpl, - Default::default(), - ), - IdentObject::Ident( + Ident::Ident("tpltest".intern(), IdentKind::Tpl, Default::default()), + Ident::Ident( "typetest".intern(), IdentKind::Type(Dtype::Integer), Default::default(), ), - IdentObject::Ident( + Ident::Ident( "mapheadtest".intern(), IdentKind::MapHead, Default::default(), ), - IdentObject::Ident( - "maptest".intern(), - IdentKind::Map, - Default::default(), - ), - IdentObject::Ident( + Ident::Ident("maptest".intern(), IdentKind::Map, Default::default()), + Ident::Ident( "maptailtest".intern(), IdentKind::MapTail, Default::default(), ), - IdentObject::Ident( + Ident::Ident( "retmapheadtest".intern(), IdentKind::RetMapHead, Default::default(), ), - IdentObject::Ident( + Ident::Ident( "retmaptest".intern(), IdentKind::RetMap, Default::default(), ), - IdentObject::Ident( + Ident::Ident( "retmaptailtest".intern(), IdentKind::RetMapTail, Default::default(), ), - IdentObject::Ident( + Ident::Ident( "metatest".intern(), IdentKind::Meta, Source { @@ -172,7 +164,7 @@ fn test_writes_deps() -> TestResult { ..Default::default() }, ), - IdentObject::Ident( + Ident::Ident( "worksheettest".intern(), IdentKind::Worksheet, Default::default(), @@ -182,15 +174,15 @@ fn test_writes_deps() -> TestResult { // Creating a stub to return our deps prevents us from being obstructed // by changes to Sections' requirements. struct StubSections<'a> { - deps: Vec<&'a IdentObject>, + deps: Vec<&'a Ident>, } impl<'a> XmleSections<'a> for StubSections<'a> { - fn push(&mut self, _ident: &'a IdentObject) -> PushResult { + fn push(&mut self, _ident: &'a Ident) -> PushResult { unimplemented!() } - fn take_deps(&mut self) -> Vec<&'a IdentObject> { + fn take_deps(&mut self) -> Vec<&'a Ident> { self.deps.clone() } @@ -358,7 +350,7 @@ fn test_writes_map_froms() -> TestResult { let mut sections = Sections::new(); let relroot = "relroot-deps".intern(); - let a = IdentObject::IdentFragment( + let a = Ident::IdentFragment( "a".intern(), IdentKind::Map, Source { @@ -368,7 +360,7 @@ fn test_writes_map_froms() -> TestResult { "fraga".intern(), ); - let b = IdentObject::IdentFragment( + let b = Ident::IdentFragment( "a".intern(), IdentKind::Map, Source { @@ -432,14 +424,14 @@ macro_rules! test_exec_sec { let frag_a = "a fragment".intern(); let frag_b = "b fragment".intern(); - let a = IdentObject::IdentFragment( + let a = Ident::IdentFragment( "a".intern(), $type, Default::default(), frag_a, ); - let b = IdentObject::IdentFragment( + let b = Ident::IdentFragment( "b".intern(), $type, Default::default(), diff --git a/tamer/src/obj/xmlo/asg_builder.rs b/tamer/src/obj/xmlo/asg_builder.rs index 4d60229b..d7c836e1 100644 --- a/tamer/src/obj/xmlo/asg_builder.rs +++ b/tamer/src/obj/xmlo/asg_builder.rs @@ -411,7 +411,7 @@ impl From for Source { #[cfg(test)] mod test { use super::*; - use crate::asg::{DefaultAsg, FragmentText, IdentKind, IdentObject}; + use crate::asg::{DefaultAsg, FragmentText, Ident, IdentKind}; use crate::num::{Dim, Dtype}; use crate::obj::xmlo::{SymAttrs, SymType}; use crate::span::{DUMMY_SPAN, UNKNOWN_SPAN}; @@ -617,7 +617,7 @@ mod test { // since this is considered to be the first package encountered. assert_eq!( - &IdentObject::Extern( + &Ident::Extern( sym_extern, IdentKind::Meta, Source { @@ -629,7 +629,7 @@ mod test { ); assert_eq!( - &IdentObject::Ident( + &Ident::Ident( sym_non_extern, IdentKind::Meta, Source { @@ -641,7 +641,7 @@ mod test { ); assert_eq!( - &IdentObject::Ident( + &Ident::Ident( sym_map, IdentKind::Map, Source { @@ -653,7 +653,7 @@ mod test { ); assert_eq!( - &IdentObject::Ident( + &Ident::Ident( sym_retmap, IdentKind::RetMap, Source { @@ -694,7 +694,7 @@ mod test { assert_eq!( // `pkg_name` retained - &IdentObject::Ident( + &Ident::Ident( sym, IdentKind::Meta, Source { @@ -736,7 +736,7 @@ mod test { assert_eq!( // `pkg_name` retained - &IdentObject::Ident( + &Ident::Ident( sym, IdentKind::Meta, Source { @@ -855,7 +855,7 @@ mod test { .expect("ident/fragment was not added to graph"); assert_eq!( - Some(&IdentObject::IdentFragment( + Some(&Ident::IdentFragment( sym, IdentKind::Meta, Default::default(), @@ -913,10 +913,7 @@ mod test { .expect("ident/fragment was not added to graph"); // The identifier should not have been modified on failure. - assert!(matches!( - sut.get(node).unwrap(), - IdentObject::Extern(_, _, _) - )); + assert!(matches!(sut.get(node).unwrap(), Ident::Extern(_, _, _))); } #[test]