employer
/
tame
1
0
Fork 0
Code Packages Releases Activity

tamer: asg: Require that all template parameters be referenced in body 

This ensures that each metavariable defined within a template (a template
parameter) has, by the time that the template definition is ended, at least
one reference to each metavariable.

This has practical benefits---ensuring that you haven't forgotten to use a
metavariable; ensuring that you clean up when code is removed; and ensuring
that you didn't accidentally delete some reference that you didn't intend to
(at least in the case of _all_ references...)---but the rationale for it in
this commit is a bit different.  More on that below.

This does introduce the negative effect of making it more difficult to
consume inputs without utilizing them, acting more like a relevant type
system (in terms of substructural type systems and with respect to
metavariables, at least).  You can for now reference them in contexts that
would reasonably have no effect on the program or be optimized away, but in
the future it'd be nice to explicitly state "hey this isn't intended to be
used yet", especially if you're creating shells of templates, or trying to
maintain BC in a particular situation.  But more on that in the future.

For now, the real reason for this change is because of how I intend for
template expansion to work: by walking the body.  Rather than having to
check both the parameters of the template and then expand the body
separately, we can simply trust that each parameter is referenced.  Then,
after rebinding metavariable references, we can perform the same check on
the expansion template to see if there were arguments provided that do not
correspond to parameters.

This also adds flexibility with parameters that are used
conditionally---we'll be able to have conditionally required parameters in
error reporting.

More information on this is coming, though; it'll be included in the docs of
the commit that introduces the changes.

DEV-13163
main
Mike Gerwitz 2023-08-16 15:17:00 -04:00
parent 0b84772853
commit bdd98a5d92
13 changed files with 356 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
tamer/src/asg/air/meta/test.rs
View File

@ -34,6 +34,7 @@ use crate::{
Air::{self, *},
},
graph::object::{meta::MetaRel, Meta, Tpl},
ExprOp,
},
parse::{util::spair, Parser},
span::{dummy::*, Span},
@ -263,14 +264,23 @@ fn assert_concat_list<'a, IT, IE: 'a>(
IE: IntoIterator<Item = &'a Meta>,
IE::IntoIter: Debug + DoubleEndedIterator,
{
let (ctx, oi_tpl) = air_ctx_from_tpl_body_toks(toks);
let meta_sym = meta_name.into();
let (ctx, oi_tpl) = air_ctx_from_tpl_body_toks(
#[rustfmt::skip]
toks.into_iter().chain(vec![
// Reference the provided metavariable to avoid
// `AsgError::TplUnusedParams`.
ExprStart(ExprOp::Sum, S20),
RefIdent(spair(meta_sym, S21)),
ExprEnd(S22),
]),
);
let asg = ctx.asg_ref();
let oi_meta = ctx
.env_scope_lookup_ident_dfn::<Meta>(
oi_tpl,
spair(meta_name.into(), DUMMY_SPAN),
)
.env_scope_lookup_ident_dfn::<Meta>(oi_tpl, spair(meta_sym, DUMMY_SPAN))
.unwrap();
// Meta references are only supported through lexical concatenation.

20
tamer/src/asg/air/test/scope.rs
View File

@ -193,6 +193,7 @@ test_scopes! {
// | :
ExprStart(ExprOp::Sum, S7), // | :
BindIdent(expr_outer), // vd|s :
RefIdent(meta_outer), // | :
ExprEnd(S9), // | :
// | :
TplStart(S10), //---. | :
@ -205,6 +206,7 @@ test_scopes! {
// 3| 2| 1: 0
ExprStart(ExprOp::Sum, S15), // | | :
BindIdent(expr_inner), // vd|s |s :
RefIdent(meta_inner), // | | :
ExprEnd(S17), // | | :
TplEnd(S18), //---' | : v,s = EnvScopeKind
TplEnd(S19), //–-----' : |
@ -359,15 +361,23 @@ test_scopes! {
MetaStart(S4), // | :
BindIdent(meta_same_a), // vl|s : <--.
MetaEnd(S6), // | : |
TplEnd(S7), //----' : |
// : |s
TplStart(S8), //----. : |a
// ENV: 3 tpl // | : |m
BindIdent(tpl_inner), // |~ : |e
// | : |
ExprStart(ExprOp::Sum, S6), // | : |
RefIdent(meta_same_a), // | : |
ExprEnd(S6), // | : |s
TplEnd(S7), //----' : |a
// : |m
TplStart(S8), //----. : |e
// ENV: 3 tpl // | : |
BindIdent(tpl_inner), // |~ : |
// | : |
MetaStart(S10), // | : |
BindIdent(meta_same_b), // vl|s : <--'
MetaEnd(S12), // | :
// | :
ExprStart(ExprOp::Sum, S12), // | :
RefIdent(meta_same_b), // | :
ExprEnd(S12), // | :
TplEnd(S13), //----' : ~ = ignored for
PkgEnd(S14), //- - - -' these tests
]

2
tamer/src/asg/air/tpl.rs
View File

@ -126,7 +126,7 @@ impl TplState {
asg: &mut Asg,
close_span: Span,
) -> Result<ObjectIndex<Tpl>, AsgError> {
let oi = self.oi().close(asg, close_span);
let oi = self.oi().close(asg, close_span)?;
match self {
Self::Dangling(_) => {

75
tamer/src/asg/air/tpl/test.rs
View File

@ -512,7 +512,14 @@ fn tpl_with_param() {
BindIdent(id_param2),
DocIndepClause(param_desc),
MetaEnd(S10),
TplEnd(S11),
// Metavariables must be used by something,
// otherwise we'll receive an error.
ExprStart(ExprOp::Sum, S11),
RefIdent(id_param1),
RefIdent(id_param2),
ExprEnd(S14),
TplEnd(S15),
];
let ctx = air_ctx_from_pkg_body_toks(toks);
@ -521,9 +528,7 @@ fn tpl_with_param() {
let oi_tpl = pkg_expect_ident_oi::<Tpl>(&ctx, id_tpl);
let tpl = oi_tpl.resolve(&asg);
// The template contains no body
// (only metavariables / params).
assert_eq!(TplShape::Empty, tpl.shape());
assert_eq!(TplShape::Expr(S11.merge(S14).unwrap()), tpl.shape());
// The template should have an edge to each identifier for each
// metavariable.
@ -677,6 +682,8 @@ fn metavars_within_exprs_hoisted_to_parent_tpl() {
MetaStart(S4),
BindIdent(id_param_outer),
MetaEnd(S6),
RefIdent(id_param_outer),
ExprEnd(S7),
// Nested template
@ -688,6 +695,8 @@ fn metavars_within_exprs_hoisted_to_parent_tpl() {
MetaStart(S11),
BindIdent(id_param_inner),
MetaEnd(S13),
RefIdent(id_param_inner),
ExprEnd(S14),
TplEnd(S15),
TplEnd(S16),
@ -932,7 +941,7 @@ fn expressions_referencing_metavars_are_abstract() {
}
// If we know of at least _one_ abstract reference,
// then it does not matter if we have missing references---​
// then it does not matter if we have missing references---
// we are abstract.
#[test]
fn expression_referencing_abstract_with_missing_is_abstract() {
@ -1097,3 +1106,59 @@ fn abstract_doc_clause_cannot_bind_to_non_meta_ref() {
.filter_map(|oi_ident| oi_ident.definition_narrow::<Expr>(asg))
.any(|oi| oi.resolve(asg).span() == S7.merge(S11).unwrap()));
}
/// All template metavariables (params) must hold at least one reference.
/// For rationale,
/// see the parent module's documentation.
#[test]
fn unused_metavars_at_definition_tpl_close_produce_error() {
#[rustfmt::skip]
let toks = [
TplStart(S1),
BindIdent(spair("_tpl", S2)),
MetaStart(S3),
BindIdent(spair("@used@", S4)), // <-.
MetaEnd(S5), // |
// |
MetaStart(S6), // |
BindIdent(spair("@unused_a@", S7)), // |
MetaEnd(S8), // |
// |
MetaStart(S9), // |
BindIdent(spair("@unused_b@", S10)), // |
MetaEnd(S11), // |
// |
ExprStart(ExprOp::Sum, S12), // |
RefIdent(spair("@used@", S13)), // --'
ExprEnd(S14),
TplEnd(S15),
];
let mut sut = parse_as_pkg_body(toks);
assert_eq!(
#[rustfmt::skip]
vec![
Err(ParseError::StateError(AsgError::TplUnusedParams(
Some(spair("_tpl", S2)),
vec![
spair("@unused_a@", S7),
spair("@unused_b@", S10),
],
))),
],
sut.by_ref().filter(Result::is_err).collect::<Vec<_>>(),
);
let ctx = sut.finalize().unwrap().into_private_context();
// The template should not have been defined.
// This is admittedly driven by implementation details:
// no other part of AIR's parsing continues with an operation despite
// an error at the time of writing.
// TODO: Should we allow the template to be defined,
// so that the user doesn't get errors saying the template doesn't
// exist?
assert_eq!(None, pkg_lookup(&ctx, spair("_tpl_", S20)));
}

33
tamer/src/asg/error.rs
View File

@ -26,7 +26,7 @@ use std::{
use crate::{
diagnose::{Annotate, AnnotatedSpan, Diagnostic},
fmt::{DisplayWrapper, TtQuote},
fmt::{AndQualConjList, DisplayWrapper, ListDisplayWrapper, TtQuote},
parse::util::SPair,
span::Span,
};
@ -195,6 +195,13 @@ pub enum AsgError {
/// The template name is provided if it is known at the time of the
/// error.
TplShapeExprMulti(Option<SPair>, ErrorOccurrenceSpan, FirstOccurrenceSpan),
/// A template has one or more concrete params that are not referred to
/// by any other object.
///
/// A param is a metavariable identifier;
/// the provided [`SPair`] is the name and span of the identifier.
TplUnusedParams(Option<SPair>, Vec<SPair>),
}
/// A [`Span`] representing the subject of this error.
@ -329,6 +336,19 @@ impl Display for AsgError {
"template definition would produce multiple inline \
expressions when expanded"
),
TplUnusedParams(oname, params) => write!(
f,
"{tpl} has {n} unused {plist}",
tpl = match oname {
Some(name) => format!("template {}", TtQuote::wrap(name)),
None => "anonymous template".into(),
},
n = params.len(),
plist = AndQualConjList::<"param:", "params:", TtQuote>::wrap(
params
),
),
}
}
}
@ -594,6 +614,17 @@ impl Diagnostic for AsgError {
),
])
.collect(),
TplUnusedParams(oname, params) => oname
.map(|name| name.note("for this template"))
.into_iter()
.chain(params.iter().map(|name| {
name.error(format!(
"param {} is not referenced",
TtQuote::wrap(name)
))
}))
.collect(),
}
}
}

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

@ -412,6 +412,33 @@ impl Asg {
.map(move |edge| ObjectIndex::<OI>::new(edge.source(), oi))
}
/// Incoming edges to `oi`.
///
/// This is intended to be utilized when
/// [`Self::incoming_edges_filtered`] cannot be used.
/// In particular,
/// this is useful when traversing the graph in reverse,
/// but does not offer the same type benefits;
/// (you must deal with a generic [`Object`] kind).
fn incoming_edges_dyn<'a>(
&'a self,
oi: ObjectIndex<Object>,
) -> impl Iterator<Item = DynObjectRel> + 'a {
self.graph
.edges_directed(oi.into(), Direction::Incoming)
.map(move |edge| {
let (src_ty, target_ty, ref_span) = edge.weight();
DynObjectRel::new(
*src_ty,
*target_ty,
oi,
ObjectIndex::<Object>::new(edge.target(), oi),
*ref_span,
)
})
}
/// Check whether an edge exists from `from` to `to.
#[inline]
pub fn has_edge<OB: ObjectRelatable>(

7
tamer/src/asg/graph/object/ident.rs
View File

@ -1493,6 +1493,13 @@ impl ObjectIndex<Ident> {
asg.create(Ident::new_abstract(at))
.add_cross_edge_to(asg, self, at)
}
/// Whether there exists at least one object that holds a reference to
/// this identifier.
pub fn is_referenced(&self, asg: &Asg) -> bool {
asg.incoming_edges_dyn(ObjectIndex::widen(*self))
.any(|edge| edge.is_cross_edge())
}
}
#[cfg(test)]

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

@ -21,7 +21,7 @@
use std::fmt::Display;
use super::{ident::IdentDefinition, prelude::*, Doc, Expr, Ident};
use super::{ident::IdentDefinition, prelude::*, Doc, Expr, Ident, Meta};
use crate::{asg::graph::ProposedRel, f::Map, parse::util::SPair, span::Span};
/// Template with associated name.
@ -376,12 +376,43 @@ impl ObjectIndex<Tpl> {
///
/// This updates the span of the template to encompass the entire
/// definition.
pub fn close(self, asg: &mut Asg, close_span: Span) -> Self {
pub fn close(
self,
asg: &mut Asg,
close_span: Span,
) -> Result<Self, AsgError> {
self.map_obj(asg, |tpl| {
tpl.map(|open_span: Span| {
open_span.merge(close_span).unwrap_or(open_span)
})
})
});
// TODO: Quick-and-dirty ignore of anonymous templates until
// following commits;
// those represent application and we'll need to present errors
// differently.
// This is temporary and will be formalized.
if self.name(asg).is_none() {
return Ok(self);
}
let mut unused = self
.edges_filtered::<Ident>(asg)
.filter(|oi| oi.is_bound_to_kind::<Meta>(asg))
.filter(|oi| !oi.is_referenced(asg))
.filter_map(|oi| oi.resolve(asg).name()) // filters out abstract
.collect::<Vec<_>>();
// Iterator above is not reversable and provides edge in the
// opposite order in which they were added
// (which would be the opposite order in which they were
// lexically defined in the source).
unused.reverse();
match unused.len() {
0 => Ok(self),
_ => Err(AsgError::TplUnusedParams(self.name(asg), unused)),
}
}
/// Apply a named template `id` to the context of `self`.

115
tamer/src/asg/graph/visit/ontree/test.rs
View File

@ -196,32 +196,28 @@ fn traverses_ontological_tree_tpl_with_sibling_at_increasing_depth() {
// unexpected way.
#[test]
fn traverses_ontological_tree_tpl_apply() {
let name_tpl = "_tpl-to-apply_".into();
let id_tpl = SPair(name_tpl, S3);
let ref_tpl = SPair(name_tpl, S6);
let id_param = SPair("@param@".into(), S8);
let value_param = SPair("value".into(), S9);
let name_tpl = "_tpl-to-apply_";
#[rustfmt::skip]
let toks = vec![
PkgStart(S1, SPair("/pkg".into(), S1)),
// The template that will be applied.
TplStart(S2),
BindIdent(id_tpl), // <-,
BindIdent(spair(name_tpl, S3)), // <-.
// |
// This test is light for now, // |
// until we develop the ASG further. // |
TplEnd(S4), // |
// |
// Apply the above template. // |
TplStart(S5), // |
RefIdent(ref_tpl), // |
// |
MetaStart(S7), // |
BindIdent(id_param), // |
MetaLexeme(value_param), // |
MetaEnd(S10), // |
TplEndRef(S11), // notice the `Ref` at the end --'
// Apply the above template. // | a
TplStart(S5), // <-+--.n
RefIdent(spair(name_tpl, S6)), // --' |o
// |n
MetaStart(S7), // |y
BindIdent(spair("@param@", S8)), // |m
MetaLexeme(spair("value", S9)), // |o
MetaEnd(S10), // |u
TplEndRef(S11), // notice the `Ref` at the end -----'s
PkgEnd(S12),
];
@ -355,21 +351,28 @@ fn traverses_ontological_tree_complex_tpl_meta() {
// -- Above this line was setup -- //
MetaStart(S4),
BindIdent(spair("@param@", S5)),
// It will be important to observe that ordering
// is respected during traversal,
// otherwise concatenation order will be wrong.
MetaLexeme(spair("foo", S6)),
RefIdent(spair("@other@", S7)), // --.
MetaLexeme(spair("bar", S8)), // |
MetaEnd(S9), // |
BindIdent(spair("@param@", S5)), // <-.
// |
MetaStart(S10), // |
BindIdent(spair("@other@", S11)), // <-'
MetaEnd(S12),
TplEnd(S13),
PkgEnd(S14),
// It will be important to observe that ordering // |
// is respected during traversal, // |
// otherwise concatenation order will be wrong. // |
MetaLexeme(spair("foo", S6)), // |
RefIdent(spair("@other@", S7)), // --. // |
MetaLexeme(spair("bar", S8)), // | // |
MetaEnd(S9), // | // |
// | // |
MetaStart(S10), // | // |
BindIdent(spair("@other@", S11)), // <-' // |
MetaEnd(S12), // |
// |
// Metavariables must all be referenced. // |
// `@other@` is already referenced above, // |
// so only `@param@` is needed. // |
ExprStart(ExprOp::Sum, S13), // |
RefIdent(spair("@param@", S14)), // --'
ExprEnd(S15),
TplEnd(S16),
PkgEnd(S17),
];
// We need more concise expressions for the below table of values.
@ -379,17 +382,19 @@ fn traverses_ontological_tree_complex_tpl_meta() {
#[rustfmt::skip]
assert_eq!(
// A -|-> B | A span -|-> B span | espan | depth
vec![//-----|-------|-----------|------------|--------|-----------------
(d(Root, Pkg, SU, m(S1, S14), None ), Depth(1)),
(d(Pkg, Ident, m(S1, S14), S3, None ), Depth(2)),
(d(Ident, Tpl, S3, m(S2, S13), None ), Depth(3)),
(d(Tpl, Ident, m(S2, S13), S5, None ), Depth(4)),
vec![//-----|-------|-----------|------------|---------|-----------------
(d(Root, Pkg, SU, m(S1, S17), None ), Depth(1)),
(d(Pkg, Ident, m(S1, S17), S3, None ), Depth(2)),
(d(Ident, Tpl, S3, m(S2, S16), None ), Depth(3)),
(d(Tpl, Ident, m(S2, S16), S5, None ), Depth(4)),
(d(Ident, Meta, S5, m(S4, S9), None ), Depth(5)),
(d(Meta, Meta, m(S4, S9), S6, None ), Depth(6)),
/*cross*/ (d(Meta, Ident, m(S4, S9), S11, Some(S7)), Depth(6)),
/*cross*/ (d(Meta, Ident, m(S4, S9), S11, Some(S7) ), Depth(6)),
(d(Meta, Meta, m(S4, S9), S8, None, ), Depth(6)),
(d(Tpl, Ident, m(S2, S13), S11, None ), Depth(4)),
(d(Tpl, Ident, m(S2, S16), S11, None ), Depth(4)),
(d(Ident, Meta, S11, m(S10, S12), None ), Depth(5)),
(d(Tpl, Expr, m(S2, S16), m(S13, S15), None ), Depth(4)),
/*cross*/ (d(Expr, Ident, m(S13, S15),S5, Some(S14)), Depth(5)),
],
tree_reconstruction_report(toks),
);
@ -439,9 +444,14 @@ fn tpl_header_source_order() {
// definitions).
ExprStart(ExprOp::Sum, S15),
BindIdent(spair("sum", S16)),
ExprEnd(S17),
TplEnd(S18),
PkgEnd(S19),
// Metavariables must be referenced.
RefIdent(spair("@param_before@", S17)),
RefIdent(spair("@param_after_a@", S18)),
RefIdent(spair("@param_after_b@", S19)),
ExprEnd(S20),
TplEnd(S21),
PkgEnd(S22),
];
// We need more concise expressions for the below table of values.
@ -451,21 +461,24 @@ fn tpl_header_source_order() {
#[rustfmt::skip]
assert_eq!(
// A -|-> B | A span -|-> B span | espan | depth
vec![//-----|-------|-----------|------------|--------|-----------------
(d(Root, Pkg, SU, m(S1, S19), None ), Depth(1)),
(d(Pkg, Ident, m(S1, S19), S3, None ), Depth(2)),
(d(Ident, Tpl, S3, m(S2, S18), None ), Depth(3)),
(d(Tpl, Ident, m(S2, S18), S5, None ), Depth(4)),
vec![//-----|-------|-----------|------------|---------|-----------------
(d(Root, Pkg, SU, m(S1, S22), None ), Depth(1)),
(d(Pkg, Ident, m(S1, S22), S3, None ), Depth(2)),
(d(Ident, Tpl, S3, m(S2, S21), None ), Depth(3)),
(d(Tpl, Ident, m(S2, S21), S5, None ), Depth(4)),
(d(Ident, Meta, S5, m(S4, S6), None ), Depth(5)),
// ,-----------------------------------------------------------------------,
(d(Tpl, Ident, m(S2, S18), S10, None ), Depth(4)),
// ,-------------------------------------------------- ---------------------,
(d(Tpl, Ident, m(S2, S21), S10, None ), Depth(4)),
(d(Ident, Meta, S10, m(S9, S11), None ), Depth(5)),
(d(Tpl, Ident, m(S2, S18), S13, None ), Depth(4)),
(d(Tpl, Ident, m(S2, S21), S13, None ), Depth(4)),
(d(Ident, Meta, S13, m(S12, S14), None ), Depth(5)),
// '-----------------------------------------------------------------------'
(d(Tpl, Expr, m(S2, S18), m(S7, S8), None ), Depth(4)),
(d(Tpl, Ident, m(S2, S18), S16, None ), Depth(4)),
(d(Ident, Expr, S16, m(S15, S17), None ), Depth(5)),
// '-------------------------------------------------- ---------------------'
(d(Tpl, Expr, m(S2, S21), m(S7, S8), None ), Depth(4)),
(d(Tpl, Ident, m(S2, S21), S16, None ), Depth(4)),
(d(Ident, Expr, S16, m(S15, S20), None ), Depth(5)),
/*cross*/ (d(Expr, Ident, m(S15, S20),S5, Some(S17)), Depth(6)),
/*cross*/ (d(Expr, Ident, m(S15, S20),S10, Some(S18)), Depth(6)),
/*cross*/ (d(Expr, Ident, m(S15, S20),S13, Some(S19)), Depth(6)),
],
// ^ The enclosed Ident->Meta pairs above have been hoisted out of
// the body and into the header of `Tpl`.

27
tamer/src/nir/abstract_bind.rs
View File

@ -119,6 +119,26 @@
//! [`Nir::BindIdentMeta`] be padded with a single `@` on each side,
//! as shown in the examples above.
//!
//! Documentation Strings
//! =====================
//! This also handles translation of metavariable references in description
//! position.
//! For example:
//!
//! ```xml
//! <classify as="foo" desc="@bar@" />
//! <!-- ^^^^^ -->
//! ```
//!
//! In this case,
//! to support the same convention as described above,
//! we want the lexeme `@bar@` to be interpreted as a _reference_
//! (to a metavariable `@bar@`),
//! not a documentation string `"@bar@"`.
//! Instead,
//! the documentation ought to be derived at expansion-time from the
//! lexical value of the metavariable identified by `@bar@`.
//!
//! Lowering Pipeline Ordering
//! ==========================
//! This module is an _optional_ syntactic feature of TAME.
@ -165,15 +185,22 @@ impl ParseState for AbstractBindTranslate {
_: &mut Self::Context,
) -> TransitionResult<Self::Super> {
match tok {
// Abstract bindings (inferred)
BindIdent(name) if needs_translation(name) => {
Transition(self).ok(BindIdentAbstract(name))
}
// Forced-abstract bindings (explicit)
BindIdentMeta(name) => validate_meta_name(name)
.map(BindIdentMeta)
.map(ParseStatus::Object)
.transition(self),
// Abstract documentation (inferred)
Desc(clause) if needs_translation(clause) => {
Transition(self).ok(DescRef(clause))
}
_ => Transition(self).ok(tok),
}
}

34
tamer/src/nir/abstract_bind/test.rs
View File

@ -162,6 +162,40 @@ fn rejects_metavariable_without_naming_convention() {
);
}
// Similar concept,
// but for `Desc`.
// This is not an abstract bind,
// though,
// making this module a slight misnomer now.
#[test]
fn desc_with_only_metavar_naming_is_translated() {
// This is named as a metavariable.
let name = "@param@".into();
assert_tok_translate(
// This documentation string uses a metavariable naming
// convention...
Desc(SPair(name, S2)),
// ...and so is translated,
// so that it is interpreted as a reference rather than a
// documentation string.
DescRef(SPair(name, S2)),
);
}
#[test]
fn desc_without_metavar_naming_is_echoed() {
// This is named as a metavariable.
let s = "some string".into();
assert_tok_translate(
// This does _not_ follow a metavariable naming convention...
Desc(SPair(s, S2)),
// ...and so is echoed back verbatim.
Desc(SPair(s, S2)),
);
}
fn assert_tok_translate(tok: Nir, expect: Nir) {
#[rustfmt::skip]
assert_eq!(

10
tamer/tests/xmli/template/expected.xml
View File

@ -186,6 +186,11 @@
<template name="_tpl-param_" desc="Template with a param">
<param name="@foo@" desc="A parameter" />
<param name="@bar@" desc="Another parameter" />
<any>
<match on="@foo@" value="TRUE" />
<match on="@bar@" value="TRUE" />
</any>
</template>
@ -204,6 +209,11 @@
<param-value name="@text@" />
<text> bar</text>
</param>
<any>
<match on="@ref@" value="TRUE" />
<match on="@both@" value="TRUE" />
</any>
</template>
</package>

10
tamer/tests/xmli/template/src.xml
View File

@ -186,6 +186,11 @@
<template name="_tpl-param_" desc="Template with a param">
<param name="@foo@" desc="A parameter" />
<param name="@bar@" desc="Another parameter" />
<any>
<match on="@foo@" />
<match on="@bar@" />
</any>
</template>
@ -204,6 +209,11 @@
<param-value name="@text@" />
<text> bar</text>
</param>
<any>
<match on="@ref@" />
<match on="@both@" />
</any>
</template>
</package>