employer
/
tame
1
0
Fork 0
Code Packages Releases Activity

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
main
Mike Gerwitz 2022-05-19 11:17:04 -04:00
parent 7d76cb53f6
commit ebf1de5a60
9 changed files with 202 additions and 235 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tamer/benches/asg.rs
View File

@ -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) {

30
tamer/src/asg/graph.rs
View File

@ -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<IdentObject>;
pub type Node = Option<Ident>;
/// 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<ObjectRef>
where
F: FnOnce(IdentObject) -> TransitionResult<IdentObject>,
F: FnOnce(Ident) -> TransitionResult<Ident>,
{
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<F>(&mut self, identi: ObjectRef, f: F) -> AsgResult<ObjectRef>
where
F: FnOnce(IdentObject) -> TransitionResult<IdentObject>,
F: FnOnce(Ident) -> TransitionResult<Ident>,
{
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<I: Into<ObjectRef>>(&self, index: I) -> Option<&IdentObject> {
pub fn get<I: Into<ObjectRef>>(&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)]

236
tamer/src/asg/ident.rs
View File

@ -37,7 +37,7 @@ pub type TransitionResult<T> = Result<T, (T, TransitionError)>;
/// `--------------------` `-----------'
/// ```
#[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<IdentObject> {
) -> TransitionResult<Ident> {
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<IdentObject> {
) -> TransitionResult<Ident> {
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<IdentObject> {
pub fn set_fragment(self, text: FragmentText) -> TransitionResult<Ident> {
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,
);
}

30
tamer/src/asg/mod.rs
View File

@ -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<dyn std::error::Error>> {
@ -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<dyn std::error::Error>> {
@ -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<dyn std::error::Error>> {
@ -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.

14
tamer/src/ld/xmle/lower.rs
View File

@ -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<SymbolId>,
{
@ -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)),

34
tamer/src/ld/xmle/section.rs
View File

@ -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<SymbolId>;
@ -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<SymbolId>,
@ -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(),

10
tamer/src/ld/xmle/xir.rs
View File

@ -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<Token, DEP_TOK_SIZE>,
/// 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,

58
tamer/src/ld/xmle/xir/test.rs
View File

@ -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(),

21
tamer/src/obj/xmlo/asg_builder.rs
View File

@ -411,7 +411,7 @@ impl From<SymAttrs> 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]