employer
/
tame
1
0
Fork 0
Code Packages Releases Activity

tamer: asg::graph: {ctx=>rel}_span: Emphasize span use 

When this span was originally introduced for an edge, I wasn't sure whether
it may have use cases beyond just references.  At this point, I'd rather be
explicit; it can evolve over time if need be.

There is nothing yet that prevents a span from being added to a tree edge,
though.

DEV-13163
main
Mike Gerwitz 2023-07-31 23:48:34 -04:00
parent 62884b2e68
commit c0ba827d90
4 changed files with 29 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -209,13 +209,13 @@ impl Asg {
&mut self, &mut self,
from_oi: OA, from_oi: OA,
to_oi: ObjectIndex<OB>, to_oi: ObjectIndex<OB>,
ctx_span: Option<Span>, ref_span: Option<Span>,
) -> Result<(), AsgError> { ) -> Result<(), AsgError> {
from_oi.pre_add_edge(self, to_oi, ctx_span, |asg| { from_oi.pre_add_edge(self, to_oi, ref_span, |asg| {
asg.graph.add_edge( asg.graph.add_edge(
from_oi.widen().into(), from_oi.widen().into(),
to_oi.into(), to_oi.into(),
(from_oi.src_rel_ty(), OB::rel_ty(), ctx_span), (from_oi.src_rel_ty(), OB::rel_ty(), ref_span),
); );
}) })
} }
@ -333,14 +333,14 @@ impl Asg {
oi: ObjectIndex<Object>, oi: ObjectIndex<Object>,
) -> impl Iterator<Item = DynObjectRel> + 'a { ) -> impl Iterator<Item = DynObjectRel> + 'a {
self.graph.edges(oi.into()).map(move |edge| { self.graph.edges(oi.into()).map(move |edge| {
let (src_ty, target_ty, ctx_span) = edge.weight(); let (src_ty, target_ty, ref_span) = edge.weight();
DynObjectRel::new( DynObjectRel::new(
*src_ty, *src_ty,
*target_ty, *target_ty,
oi, oi,
ObjectIndex::<Object>::new(edge.target(), oi), ObjectIndex::<Object>::new(edge.target(), oi),
*ctx_span, *ref_span,
) )
}) })
} }
@ -542,7 +542,7 @@ impl<OA: ObjectRelatable, OB: ObjectRelatable> AsgRelMut<OB> for OA {
pub struct ProposedRel<OA: ObjectKind, OB: ObjectKind> { pub struct ProposedRel<OA: ObjectKind, OB: ObjectKind> {
from_oi: ObjectIndex<OA>, from_oi: ObjectIndex<OA>,
to_oi: ObjectIndex<OB>, to_oi: ObjectIndex<OB>,
ctx_span: Option<Span>, ref_span: Option<Span>,
} }
#[cfg(test)] #[cfg(test)]

36
tamer/src/asg/graph/object/rel.rs
View File

@ -198,7 +198,7 @@ macro_rules! object_rel {
// on its own; // on its own;
// an edge only needs supplemental span information if there is // an edge only needs supplemental span information if there is
// another context in which that object is referenced. // another context in which that object is referenced.
(@is_cross_edge dyn $rel:ident) => { $rel.ctx_span().is_some() }; (@is_cross_edge dyn $rel:ident) => { $rel.ref_span().is_some() };
// Similar to above but providing _static_ information to the type // Similar to above but providing _static_ information to the type
// system. // system.
@ -234,9 +234,9 @@ impl<S, T> DynObjectRel<S, T> {
to_ty: ObjectRelTy, to_ty: ObjectRelTy,
src: S, src: S,
target: T, target: T,
ctx_span: Option<Span>, ref_span: Option<Span>,
) -> Self { ) -> Self {
Self((from_ty, to_ty), (src, target), ctx_span) Self((from_ty, to_ty), (src, target), ref_span)
} }
/// The type of the source edge. /// The type of the source edge.
@ -270,12 +270,16 @@ impl<S, T> DynObjectRel<S, T> {
} }
} }
/// A [`Span`] associated with the _relationship_ between the source and /// A [`Span`] representing the reference location of a relationship.
/// target objects, ///
/// if any. /// This value indicates that the edge represents a cross edge.
pub fn ctx_span(&self) -> Option<Span> { /// In this case,
/// a separate span is needed to provide information about the source
/// location of the reference,
/// rather than the object that has been referenced.
pub fn ref_span(&self) -> Option<Span> {
match self { match self {
Self(_, _, ctx_span) => *ctx_span, Self(_, _, ref_span) => *ref_span,
} }
} }
} }
@ -486,7 +490,7 @@ impl<S, T, U, V> Map<(S, T), (U, V)> for DynObjectRel<S, T> {
fn map(self, f: impl FnOnce((S, T)) -> (U, V)) -> Self::Target { fn map(self, f: impl FnOnce((S, T)) -> (U, V)) -> Self::Target {
match self { match self {
Self(tys, x, ctx_span) => DynObjectRel(tys, f(x), ctx_span), Self(tys, x, ref_span) => DynObjectRel(tys, f(x), ref_span),
} }
} }
} }
@ -863,7 +867,7 @@ pub trait ObjectIndexRelTo<OB: ObjectRelatable>: Sized + Clone + Copy {
&self, &self,
asg: &mut Asg, asg: &mut Asg,
to_oi: ObjectIndex<OB>, to_oi: ObjectIndex<OB>,
ctx_span: Option<Span>, ref_span: Option<Span>,
commit: impl FnOnce(&mut Asg), commit: impl FnOnce(&mut Asg),
) -> Result<(), AsgError>; ) -> Result<(), AsgError>;
@ -947,7 +951,7 @@ where
&self, &self,
asg: &mut Asg, asg: &mut Asg,
to_oi: ObjectIndex<OB>, to_oi: ObjectIndex<OB>,
ctx_span: Option<Span>, ref_span: Option<Span>,
commit: impl FnOnce(&mut Asg), commit: impl FnOnce(&mut Asg),
) -> Result<(), AsgError> { ) -> Result<(), AsgError> {
O::pre_add_edge( O::pre_add_edge(
@ -955,7 +959,7 @@ where
ProposedRel { ProposedRel {
from_oi: self.widen().must_narrow_into::<O>(), from_oi: self.widen().must_narrow_into::<O>(),
to_oi, to_oi,
ctx_span, ref_span,
}, },
commit, commit,
) )
@ -977,7 +981,7 @@ impl<OB: ObjectRelatable> ObjectIndexRelTo<OB> for ObjectIndexTo<OB> {
&self, &self,
asg: &mut Asg, asg: &mut Asg,
to_oi: ObjectIndex<OB>, to_oi: ObjectIndex<OB>,
ctx_span: Option<Span>, ref_span: Option<Span>,
commit: impl FnOnce(&mut Asg), commit: impl FnOnce(&mut Asg),
) -> Result<(), AsgError> { ) -> Result<(), AsgError> {
macro_rules! pre_add_edge { macro_rules! pre_add_edge {
@ -987,7 +991,7 @@ impl<OB: ObjectRelatable> ObjectIndexRelTo<OB> for ObjectIndexTo<OB> {
ProposedRel { ProposedRel {
from_oi: self.widen().must_narrow_into::<$ty>(), from_oi: self.widen().must_narrow_into::<$ty>(),
to_oi, to_oi,
ctx_span, ref_span,
}, },
commit, commit,
) )
@ -1023,11 +1027,11 @@ impl<OB: ObjectRelatable> ObjectIndexRelTo<OB> for ObjectIndexToTree<OB> {
&self, &self,
asg: &mut Asg, asg: &mut Asg,
to_oi: ObjectIndex<OB>, to_oi: ObjectIndex<OB>,
ctx_span: Option<Span>, ref_span: Option<Span>,
commit: impl FnOnce(&mut Asg), commit: impl FnOnce(&mut Asg),
) -> Result<(), AsgError> { ) -> Result<(), AsgError> {
match self { match self {
Self(oito) => oito.pre_add_edge(asg, to_oi, ctx_span, commit), Self(oito) => oito.pre_add_edge(asg, to_oi, ref_span, commit),
} }
} }
} }

2
tamer/src/asg/graph/object/tpl.rs
View File

@ -266,7 +266,7 @@ object_rel! {
) -> Result<(), AsgError> { ) -> Result<(), AsgError> {
let tpl_name = rel.from_oi.name(asg); let tpl_name = rel.from_oi.name(asg);
match (rel.ctx_span, rel.to_oi.definition(asg)) { match (rel.ref_span, rel.to_oi.definition(asg)) {
// Missing definition results in shape uncertainty that // Missing definition results in shape uncertainty that
// will have to be resolved when (if) a definition // will have to be resolved when (if) a definition
// becomes available. // becomes available.

4
tamer/src/asg/graph/visit/ontree.rs
View File

@ -313,10 +313,10 @@ impl Token for TreeWalkRel {
/// while concrete spans are stored on the objects that those /// while concrete spans are stored on the objects that those
/// relationships reference. /// relationships reference.
/// This will return a potentially-useful span only if the inner /// This will return a potentially-useful span only if the inner
/// [`DynObjectRel::ctx_span`] does. /// [`DynObjectRel::ref_span`] does.
fn span(&self) -> Span { fn span(&self) -> Span {
match self { match self {
Self(dyn_rel, _) => dyn_rel.ctx_span().unwrap_or(UNKNOWN_SPAN), Self(dyn_rel, _) => dyn_rel.ref_span().unwrap_or(UNKNOWN_SPAN),
} }
} }
} }