1use std::collections::{HashMap, HashSet};
28
29use crate::ast::{
30 AstNode, Command, Optional, child, children, command_name, control_word_range,
31 group_command_name, group_inner_source, nth_group, nth_group_inner, nth_group_text,
32};
33use crate::semantic::signature::{
34 ArgKind, ArgSpec, CommandSig, ContentKind, EnvironmentSig, SignatureDb, builtin,
35};
36use crate::semantic::xparse;
37use crate::syntax::{SyntaxKind, SyntaxNode, is_collapsible_trivia, is_trivia};
38use rowan::{NodeOrToken, TextRange, TextSize};
39use smol_str::SmolStr;
40
41pub fn scan_definitions(root: &SyntaxNode) -> SignatureDb {
46 let mut db = SignatureDb::default();
47 let mut bodies: HashMap<SmolStr, DefBody> = HashMap::new();
51 let mut env_bodies: HashMap<SmolStr, DefBody> = HashMap::new();
56 let mut alias_candidates: HashMap<SmolStr, EnvAliasCandidate> = HashMap::new();
61
62 for command in root
63 .descendants()
64 .filter(|node| node.kind() == SyntaxKind::COMMAND)
65 {
66 let Some(name) = command_name(&command) else {
67 continue;
68 };
69 match DefKind::of(&name) {
70 Some(DefKind::Command) => {
71 scan_newcommand(&command, &mut db, &mut bodies, &mut alias_candidates)
72 }
73 Some(DefKind::Def) => scan_def(&command, &mut db, &mut bodies, &mut alias_candidates),
74 Some(DefKind::Environment) => scan_newenvironment(&command, &mut db, &mut env_bodies),
75 Some(DefKind::XparseCommand) => {
76 scan_xparse_command(&command, &mut db, &mut bodies, &mut alias_candidates)
77 }
78 Some(DefKind::XparseEnvironment) => {
79 scan_xparse_environment(&command, &mut db, &mut env_bodies)
80 }
81 Some(DefKind::VerbatimEnvironment) => {
82 scan_verbatim_environment(&name, &command, &mut db)
83 }
84 None => {}
85 }
86 }
87
88 apply_verbatim_flags(&mut db, &bodies);
89 apply_verbatim_env_flags(&mut db, &env_bodies, &bodies);
90 apply_env_aliases(&mut db, &alias_candidates);
91 db
92}
93
94#[derive(Debug, Clone, Copy, PartialEq, Eq)]
96enum AliasSide {
97 Begin,
98 End,
99}
100
101#[derive(Debug, Clone)]
105struct EnvAliasCandidate {
106 side: AliasSide,
107 target: SmolStr,
108}
109
110fn env_alias_body(body: &SyntaxNode) -> Option<EnvAliasCandidate> {
122 let mut sole: Option<SyntaxNode> = None;
123 for child in body.children_with_tokens() {
124 match child {
125 NodeOrToken::Token(t) => match t.kind() {
126 SyntaxKind::L_BRACE | SyntaxKind::R_BRACE | SyntaxKind::COMMENT => {}
128 k if is_collapsible_trivia(k) => {}
129 _ => return None,
130 },
131 NodeOrToken::Node(n) => {
133 if sole.replace(n).is_some() {
134 return None;
135 }
136 }
137 }
138 }
139 let cmd = sole?;
140 if cmd.kind() != SyntaxKind::COMMAND {
141 return None;
142 }
143 if cmd.children().count() != 1 {
146 return None;
147 }
148 let side = match command_name(&cmd)?.as_str() {
149 "begin" => AliasSide::Begin,
150 "end" => AliasSide::End,
151 _ => return None,
152 };
153 let target = nth_group_text(&cmd, 0)?;
154 let target = target.trim();
155 if target.is_empty() {
156 return None;
157 }
158 Some(EnvAliasCandidate {
159 side,
160 target: SmolStr::new(target),
161 })
162}
163
164fn record_env_alias(
169 candidates: &mut HashMap<SmolStr, EnvAliasCandidate>,
170 name: &str,
171 arity: usize,
172 body: Option<&SyntaxNode>,
173) {
174 candidates.remove(name);
178 if arity != 0 {
179 return;
180 }
181 if let Some(candidate) = body.and_then(env_alias_body) {
182 candidates.insert(SmolStr::new(name), candidate);
183 }
184}
185
186fn apply_env_aliases(db: &mut SignatureDb, candidates: &HashMap<SmolStr, EnvAliasCandidate>) {
212 let admissible = |target: &str| {
213 builtin()
214 .environment(target)
215 .is_some_and(|sig| !sig.verbatim_body && sig.args.is_empty())
216 };
217 for (name, candidate) in candidates {
218 let target = candidate.target.as_str();
219 if !admissible(target) {
220 continue;
221 }
222 match candidate.side {
223 AliasSide::Begin => {
224 db.insert_env_begin_alias(name.clone(), candidate.target.clone());
225 }
226 AliasSide::End => {
227 db.insert_env_end_alias(name.clone(), candidate.target.clone());
228 }
229 }
230 }
231}
232
233#[derive(Debug, Clone, Copy, PartialEq, Eq)]
236pub enum DefSiteKind {
237 Command,
238 Environment,
239}
240
241#[derive(Debug, Clone, PartialEq, Eq)]
247pub struct DefSite {
248 pub name: SmolStr,
250 pub kind: DefSiteKind,
251 pub name_range: TextRange,
258 pub range: TextRange,
261}
262
263pub fn scan_definition_sites(root: &SyntaxNode) -> Vec<DefSite> {
269 let mut sites = Vec::new();
270 for command in root
271 .descendants()
272 .filter(|node| node.kind() == SyntaxKind::COMMAND)
273 {
274 let Some(name) = command_name(&command) else {
275 continue;
276 };
277 let site = match DefKind::of(&name) {
278 Some(DefKind::Command | DefKind::XparseCommand) => command_def_site(&command),
279 Some(DefKind::Def) => def_def_site(&command),
280 Some(
281 DefKind::Environment | DefKind::XparseEnvironment | DefKind::VerbatimEnvironment,
282 ) => environment_def_site(&command),
283 None => None,
284 };
285 sites.extend(site);
286 }
287 sites
288}
289
290fn command_def_site(command: &SyntaxNode) -> Option<DefSite> {
295 let def = resolve_command_def(command)?;
296 let name_range = if def.first_arg_group == 1 {
297 let group = nth_group(command, 0)?;
298 child::<Command>(&group)?.control_word_range()?
299 } else {
300 control_word_range(&def.host)?
301 };
302 Some(DefSite {
303 name: SmolStr::new(&def.name),
304 kind: DefSiteKind::Command,
305 name_range,
306 range: TextRange::new(
307 command.text_range().start(),
308 command.text_range().end().max(def.host.text_range().end()),
309 ),
310 })
311}
312
313fn def_def_site(command: &SyntaxNode) -> Option<DefSite> {
316 let name_node = adjacent_sibling_command(command)?;
317 let name = command_name(&name_node)?;
318 let name_range = control_word_range(&name_node)?;
319 Some(DefSite {
320 name: SmolStr::new(&name),
321 kind: DefSiteKind::Command,
322 name_range,
323 range: TextRange::new(command.text_range().start(), name_node.text_range().end()),
324 })
325}
326
327fn environment_def_site(command: &SyntaxNode) -> Option<DefSite> {
331 let (inner_range, text) = nth_group_inner(command, 0)?;
332 let trimmed = text.trim();
333 if trimmed.is_empty() {
334 return None;
335 }
336 let leading = text.len() - text.trim_start().len();
337 let name_range = TextRange::at(
338 inner_range.start() + TextSize::new(leading as u32),
339 TextSize::new(trimmed.len() as u32),
340 );
341 Some(DefSite {
342 name: SmolStr::new(trimmed),
343 kind: DefSiteKind::Environment,
344 name_range,
345 range: command.text_range(),
346 })
347}
348
349struct DefBody {
353 signal: bool,
356 called: Vec<SmolStr>,
359}
360
361fn apply_verbatim_flags(db: &mut SignatureDb, bodies: &HashMap<SmolStr, DefBody>) {
373 let verbatim: Vec<SmolStr> = bodies
374 .keys()
375 .filter(|name| {
376 db.command(name).is_some_and(|sig| !sig.args.is_empty())
378 && reaches_signal(name, bodies, &mut HashSet::new())
379 })
380 .cloned()
381 .collect();
382
383 for name in verbatim {
384 if let Some(mut sig) = db.command(&name).cloned() {
385 sig.args.to_mut().pop(); sig.verbatim = true;
387 db.insert_command(name, sig);
388 }
389 }
390}
391
392fn apply_verbatim_env_flags(
401 db: &mut SignatureDb,
402 env_bodies: &HashMap<SmolStr, DefBody>,
403 bodies: &HashMap<SmolStr, DefBody>,
404) {
405 let verbatim: Vec<SmolStr> = env_bodies
406 .iter()
407 .filter(|(name, body)| {
408 db.environment(name).is_some() && reaches_signal_body(body, bodies, &mut HashSet::new())
409 })
410 .map(|(name, _)| name.clone())
411 .collect();
412
413 for name in verbatim {
414 if let Some(mut sig) = db.environment(&name).cloned() {
415 sig.verbatim_body = true;
416 db.insert_environment(name, sig);
417 }
418 }
419}
420
421fn reaches_signal(
427 name: &str,
428 bodies: &HashMap<SmolStr, DefBody>,
429 visited: &mut HashSet<SmolStr>,
430) -> bool {
431 if !visited.insert(SmolStr::new(name)) {
432 return false;
433 }
434 let Some(body) = bodies.get(name) else {
435 return false;
436 };
437 reaches_signal_body(body, bodies, visited)
438}
439
440fn reaches_signal_body(
446 body: &DefBody,
447 bodies: &HashMap<SmolStr, DefBody>,
448 visited: &mut HashSet<SmolStr>,
449) -> bool {
450 body.signal
451 || body
452 .called
453 .iter()
454 .any(|callee| reaches_signal(callee, bodies, visited))
455}
456
457fn catcode_signal(body: &str) -> bool {
462 body.contains("\\@makeother")
463 || body.contains("\\@sanitize")
464 || body.contains("\\dospecials")
465 || body
466 .match_indices("\\catcode")
467 .any(|(start, _)| catcode_assigns_other(&body[start + "\\catcode".len()..]))
468}
469
470fn catcode_assigns_other(tail: &str) -> bool {
476 let mut chars = tail.chars();
477 if chars
478 .clone()
479 .next()
480 .is_some_and(|c| c.is_ascii_alphabetic() || matches!(c, '@' | '_' | ':'))
481 {
482 return false;
483 }
484
485 let mut after_equals = chars
486 .by_ref()
487 .take(64)
488 .skip_while(|&c| c != '=')
489 .skip(1)
490 .skip_while(|c| c.is_whitespace());
491 after_equals.next() == Some('1')
492 && after_equals.next() == Some('2')
493 && !after_equals.next().is_some_and(|c| c.is_ascii_digit())
494}
495
496fn called_macros(body: &str) -> Vec<SmolStr> {
501 body.match_indices('\\')
502 .filter_map(|(pos, _)| {
503 let after = &body[pos + 1..];
504 let len: usize = after
505 .chars()
506 .take_while(|c| c.is_ascii_alphabetic() || *c == '@')
507 .map(char::len_utf8)
508 .sum();
509 (len > 0).then(|| SmolStr::new(&after[..len]))
510 })
511 .collect()
512}
513
514const DELEGATING_PRIMITIVES: &[&str] = &["secdef", "@startsection", "@dblarg", "@sect", "@ssect"];
524
525fn keeps_builtin_over_arity0(name: &str, arity: usize, body: &DefBody) -> bool {
536 arity == 0
537 && body
538 .called
539 .iter()
540 .any(|callee| DELEGATING_PRIMITIVES.contains(&callee.as_str()))
541 && crate::semantic::signature::builtin()
542 .command(name)
543 .is_some()
544}
545
546pub fn is_definition_command(name: &str) -> bool {
553 DefKind::of(name).is_some()
554}
555
556enum DefKind {
558 Command,
559 Def,
560 Environment,
561 XparseCommand,
562 XparseEnvironment,
563 VerbatimEnvironment,
568}
569
570impl DefKind {
571 fn of(name: &str) -> Option<Self> {
572 Some(match name {
573 "newcommand" | "renewcommand" | "providecommand" | "DeclareRobustCommand" => {
574 DefKind::Command
575 }
576 "def" | "edef" | "gdef" | "xdef" => DefKind::Def,
579 "newenvironment" | "renewenvironment" => DefKind::Environment,
580 "NewDocumentCommand"
581 | "RenewDocumentCommand"
582 | "ProvideDocumentCommand"
583 | "DeclareDocumentCommand" => DefKind::XparseCommand,
584 "NewDocumentEnvironment"
585 | "RenewDocumentEnvironment"
586 | "ProvideDocumentEnvironment"
587 | "DeclareDocumentEnvironment" => DefKind::XparseEnvironment,
588 "lstnewenvironment" | "DefineVerbatimEnvironment" => DefKind::VerbatimEnvironment,
591 _ => return None,
592 })
593 }
594}
595
596fn scan_newcommand(
602 command: &SyntaxNode,
603 db: &mut SignatureDb,
604 bodies: &mut HashMap<SmolStr, DefBody>,
605 aliases: &mut HashMap<SmolStr, EnvAliasCandidate>,
606) {
607 let Some(def) = resolve_command_def(command) else {
608 return;
609 };
610 let (arity, first_optional) = newcommand_arity(&def.host);
611 let body = nth_group(&def.host, def.first_arg_group);
614 record_body(bodies, &def.name, body.as_ref());
615 record_env_alias(aliases, &def.name, arity, body.as_ref());
616 if bodies
620 .get(def.name.as_str())
621 .is_some_and(|body| keeps_builtin_over_arity0(&def.name, arity, body))
622 {
623 return;
624 }
625 db.insert_command(
626 def.name,
627 CommandSig {
628 args: latex2e_args(arity, first_optional).into(),
629 sectioning: None,
630 verbatim: false,
631 verbatim_delimited: false,
632 rule: false,
633 inline: false,
634 citation: None,
635 block: false,
639 },
640 );
641}
642
643fn scan_def(
651 command: &SyntaxNode,
652 db: &mut SignatureDb,
653 bodies: &mut HashMap<SmolStr, DefBody>,
654 aliases: &mut HashMap<SmolStr, EnvAliasCandidate>,
655) {
656 let Some(name_node) = adjacent_sibling_command(command) else {
657 return;
658 };
659 let Some(name) = command_name(&name_node) else {
660 return;
661 };
662 let (arity, body) = def_params_and_body(&name_node);
663 record_body(bodies, &name, body.as_ref());
664 record_env_alias(aliases, &name, arity, body.as_ref());
665 if bodies
668 .get(name.as_str())
669 .is_some_and(|body| keeps_builtin_over_arity0(&name, arity, body))
670 {
671 return;
672 }
673 db.insert_command(
674 name,
675 CommandSig {
676 args: latex2e_args(arity, false).into(),
680 sectioning: None,
681 verbatim: false,
682 verbatim_delimited: false,
683 rule: false,
684 inline: false,
685 citation: None,
686 block: false,
690 },
691 );
692}
693
694fn def_params_and_body(name_node: &SyntaxNode) -> (usize, Option<SyntaxNode>) {
707 if let Some(body) = nth_group(name_node, 0) {
709 return (0, Some(body));
710 }
711 let mut arity = 0usize;
713 let mut next = name_node.next_sibling_or_token();
714 while let Some(element) = next {
715 match element {
716 NodeOrToken::Token(token) if is_trivia(token.kind()) => {
717 next = token.next_sibling_or_token();
718 }
719 NodeOrToken::Token(token) if token.kind() == SyntaxKind::HASH => {
720 arity += 1;
721 next = token.next_sibling_or_token();
722 }
723 NodeOrToken::Token(token) if token.kind() == SyntaxKind::WORD => {
725 next = token.next_sibling_or_token();
726 }
727 NodeOrToken::Node(node) if node.kind() == SyntaxKind::GROUP => {
728 return (arity.min(9), Some(node));
729 }
730 _ => return (arity.min(9), None),
731 }
732 }
733 (arity.min(9), None)
734}
735
736fn record_body(bodies: &mut HashMap<SmolStr, DefBody>, name: &str, body: Option<&SyntaxNode>) {
739 let text = body.map(group_inner_source).unwrap_or_default();
740 bodies.insert(
741 SmolStr::new(name),
742 DefBody {
743 signal: catcode_signal(&text),
744 called: called_macros(&text),
745 },
746 );
747}
748
749fn scan_newenvironment(
754 command: &SyntaxNode,
755 db: &mut SignatureDb,
756 env_bodies: &mut HashMap<SmolStr, DefBody>,
757) {
758 let Some(name) = nth_group_text(command, 0) else {
759 return;
760 };
761 let name = name.trim();
762 if name.is_empty() {
763 return;
764 }
765 record_body(env_bodies, name, nth_group(command, 1).as_ref());
766 let (arity, first_optional) = newcommand_arity(command);
767 db.insert_environment(name, environment_sig(latex2e_args(arity, first_optional)));
768}
769
770fn scan_verbatim_environment(defining_command: &str, command: &SyntaxNode, db: &mut SignatureDb) {
780 let Some(name) = nth_group_text(command, 0) else {
781 return;
782 };
783 let name = name.trim();
784 if name.is_empty() {
785 return;
786 }
787 let args = if defining_command == "lstnewenvironment" {
788 let (arity, first_optional) = newcommand_arity(command);
789 latex2e_args(arity, first_optional)
790 } else {
791 latex2e_args(1, true)
793 };
794 let mut sig = environment_sig(args);
795 sig.verbatim_body = true;
796 db.insert_environment(name, sig);
797}
798
799fn scan_xparse_command(
804 command: &SyntaxNode,
805 db: &mut SignatureDb,
806 bodies: &mut HashMap<SmolStr, DefBody>,
807 aliases: &mut HashMap<SmolStr, EnvAliasCandidate>,
808) {
809 let Some(def) = resolve_command_def(command) else {
810 return;
811 };
812 let Some(spec) = nth_group(&def.host, def.first_arg_group) else {
813 return;
814 };
815 let body = nth_group(&def.host, def.first_arg_group + 1);
817 record_body(bodies, &def.name, body.as_ref());
818 let args = xparse::parse_spec(&group_inner_source(&spec));
819 record_env_alias(aliases, &def.name, args.len(), body.as_ref());
820 db.insert_command(
821 def.name,
822 CommandSig {
823 args: args.into(),
824 sectioning: None,
825 verbatim: false,
826 verbatim_delimited: false,
827 rule: false,
828 inline: false,
829 citation: None,
830 block: false,
834 },
835 );
836}
837
838struct CommandDef {
849 name: SmolStr,
850 host: SyntaxNode,
851 first_arg_group: usize,
852}
853
854fn resolve_command_def(command: &SyntaxNode) -> Option<CommandDef> {
858 if command.children().any(|c| c.kind() == SyntaxKind::GROUP) {
861 let name = nth_group(command, 0)
862 .as_ref()
863 .and_then(group_command_name)?;
864 return Some(CommandDef {
865 name,
866 host: command.clone(),
867 first_arg_group: 1,
868 });
869 }
870 let sibling = adjacent_sibling_command(command)?;
874 let name = command_name(&sibling)?;
875 Some(CommandDef {
876 name,
877 host: sibling,
878 first_arg_group: 0,
879 })
880}
881
882fn adjacent_sibling_command(command: &SyntaxNode) -> Option<SyntaxNode> {
888 let mut next = command.next_sibling_or_token();
889 while let Some(element) = next {
890 match element {
891 NodeOrToken::Token(token) if is_trivia(token.kind()) => {
892 next = token.next_sibling_or_token();
893 }
894 NodeOrToken::Node(node) if node.kind() == SyntaxKind::COMMAND => return Some(node),
895 _ => return None,
896 }
897 }
898 None
899}
900
901fn scan_xparse_environment(
905 command: &SyntaxNode,
906 db: &mut SignatureDb,
907 env_bodies: &mut HashMap<SmolStr, DefBody>,
908) {
909 let Some(name) = nth_group_text(command, 0) else {
910 return;
911 };
912 let name = name.trim();
913 if name.is_empty() {
914 return;
915 }
916 let Some(spec) = nth_group(command, 1) else {
917 return;
918 };
919 record_body(env_bodies, name, nth_group(command, 2).as_ref());
920 db.insert_environment(
921 name,
922 environment_sig(xparse::parse_spec(&group_inner_source(&spec))),
923 );
924}
925
926fn newcommand_arity(command: &SyntaxNode) -> (usize, bool) {
930 let optionals: Vec<Optional> = children::<Optional>(command).collect();
931 let arity = optionals
932 .first()
933 .map(|o| o.syntax())
934 .and_then(optional_number)
935 .unwrap_or(0)
936 .min(9); (arity, optionals.len() >= 2)
938}
939
940fn optional_number(node: &SyntaxNode) -> Option<usize> {
943 let text = node.text().to_string();
944 let inner = text.strip_prefix('[').unwrap_or(&text);
945 let inner = inner.strip_suffix(']').unwrap_or(inner);
946 inner.trim().parse().ok()
947}
948
949fn latex2e_args(arity: usize, first_optional: bool) -> Vec<ArgSpec> {
952 (0..arity)
953 .map(|i| {
954 if i == 0 && first_optional {
955 ArgSpec {
956 required: false,
957 kind: ArgKind::Bracket,
958 content: ContentKind::Opaque,
959 domain: crate::semantic::ArgumentDomain::Unknown,
960 verbatim: false,
961 }
962 } else {
963 ArgSpec {
964 required: true,
965 kind: ArgKind::Brace,
966 content: ContentKind::Opaque,
967 domain: crate::semantic::ArgumentDomain::Unknown,
968 verbatim: false,
969 }
970 }
971 })
972 .collect()
973}
974
975fn environment_sig(args: Vec<ArgSpec>) -> EnvironmentSig {
979 EnvironmentSig {
980 args: args.into(),
981 verbatim_body: false,
982 verbatim_arg: false,
985 math: false,
986 code: false,
987 statement_body: false,
990 label_key: false,
992 caption_container: false,
994 align: false,
995 no_indent: false,
996 list: false,
999 block_explicit: false,
1003 outline: None,
1006 }
1007}
1008
1009#[cfg(test)]
1010mod tests {
1011 use super::*;
1012 use crate::parser::{parse, reconstruct};
1013
1014 fn db_of(src: &str) -> SignatureDb {
1015 assert_eq!(reconstruct(src), src, "reconstruct must round-trip");
1016 scan_definitions(&SyntaxNode::new_root(parse(src).green))
1017 }
1018
1019 fn arg_kinds(args: &[ArgSpec]) -> Vec<ArgKind> {
1020 args.iter().map(|a| a.kind).collect()
1021 }
1022
1023 #[test]
1024 fn newcommand_counts_mandatory_args() {
1025 let db = db_of("\\newcommand{\\foo}[2]{#1#2}\n");
1026 let sig = db.command("foo").expect("foo defined");
1027 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Brace, ArgKind::Brace]);
1028 assert!(sig.args.iter().all(|a| a.required));
1029 assert!(
1030 sig.args
1031 .iter()
1032 .all(|arg| arg.domain == crate::semantic::ArgumentDomain::Unknown)
1033 );
1034 }
1035
1036 #[test]
1037 fn newcommand_optional_first_arg() {
1038 let db = db_of("\\newcommand{\\foo}[2][d]{#1#2}\n");
1039 let sig = db.command("foo").expect("foo defined");
1040 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Bracket, ArgKind::Brace]);
1041 assert!(!sig.args[0].required);
1042 assert!(sig.args[1].required);
1043 }
1044
1045 #[test]
1046 fn newcommand_zero_args() {
1047 let db = db_of("\\newcommand{\\foo}{bar}\n");
1048 assert!(db.command("foo").expect("foo defined").args.is_empty());
1049 }
1050
1051 #[test]
1052 fn renew_and_provide_recognized() {
1053 let db = db_of("\\renewcommand{\\a}[1]{x}\\providecommand{\\b}[1]{y}\n");
1054 assert_eq!(db.command("a").unwrap().args.len(), 1);
1055 assert_eq!(db.command("b").unwrap().args.len(), 1);
1056 }
1057
1058 #[test]
1059 fn secdef_redefinition_keeps_builtin_prose() {
1060 let db = db_of("\\renewcommand{\\section}{\\secdef \\a \\b}\n");
1061 assert!(
1062 db.command("section").is_none(),
1063 "the delegating redefinition must not be recorded as a scanned override"
1064 );
1065 let sigs = crate::semantic::signature::Signatures::new(&db);
1066 let sig = sigs.command("section").expect("built-in section survives");
1067 let last = sig.args.last().expect("section keeps its title argument");
1068 assert_eq!(
1069 last.content,
1070 crate::semantic::signature::ContentKind::Prose,
1071 "the title argument stays prose (reflowable)"
1072 );
1073 }
1074
1075 #[test]
1076 fn genuine_zero_arg_redefinition_downgrades_builtin() {
1077 let db = db_of("\\renewcommand{\\section}{\\textbf{Fixed}}\n");
1078 let sig = db
1079 .command("section")
1080 .expect("genuine 0-arg redefinition is recorded");
1081 assert!(
1082 sig.args.is_empty(),
1083 "no delegation means the scanned 0-arg signature wins"
1084 );
1085 }
1086
1087 #[test]
1088 fn secdef_redefinition_of_unknown_still_records() {
1089 let db = db_of("\\renewcommand{\\mysec}{\\secdef \\a \\b}\n");
1090 let sig = db.command("mysec").expect("unknown name is still recorded");
1091 assert!(sig.args.is_empty());
1092 }
1093
1094 #[test]
1095 fn newenvironment_args() {
1096 let db = db_of("\\newenvironment{thm}[1]{begin #1}{end}\n");
1097 let sig = db.environment("thm").expect("thm defined");
1098 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Brace]);
1099 assert!(sig.reflow());
1100 assert!(!sig.verbatim_body);
1101 assert!(!sig.math);
1102 }
1103
1104 #[test]
1105 fn xparse_command_spec() {
1106 let db = db_of("\\NewDocumentCommand{\\foo}{m O{d} m}{x}\n");
1107 let sig = db.command("foo").expect("foo defined");
1108 assert_eq!(
1109 arg_kinds(&sig.args),
1110 vec![ArgKind::Brace, ArgKind::Bracket, ArgKind::Brace]
1111 );
1112 assert!(
1113 sig.args
1114 .iter()
1115 .all(|arg| arg.domain == crate::semantic::ArgumentDomain::Unknown)
1116 );
1117 }
1118
1119 #[test]
1120 fn xparse_environment_spec() {
1121 let db = db_of("\\NewDocumentEnvironment{env}{O{x} m}{a}{b}\n");
1122 let sig = db.environment("env").expect("env defined");
1123 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Bracket, ArgKind::Brace]);
1124 assert!(
1125 sig.args
1126 .iter()
1127 .all(|arg| arg.domain == crate::semantic::ArgumentDomain::Unknown)
1128 );
1129 }
1130
1131 #[test]
1132 fn unbraced_newcommand_extracted() {
1133 let db = db_of("\\newcommand\\foo[2]{#1#2}\n");
1134 let sig = db.command("foo").expect("foo defined");
1135 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Brace, ArgKind::Brace]);
1136 assert!(sig.args.iter().all(|a| a.required));
1137 }
1138
1139 #[test]
1140 fn unbraced_optional_first_arg() {
1141 let db = db_of("\\newcommand\\foo[2][d]{#1#2}\n");
1142 let sig = db.command("foo").expect("foo defined");
1143 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Bracket, ArgKind::Brace]);
1144 assert!(!sig.args[0].required);
1145 assert!(sig.args[1].required);
1146 }
1147
1148 #[test]
1149 fn unbraced_zero_args() {
1150 let db = db_of("\\newcommand\\foo{x}\n");
1151 assert!(db.command("foo").expect("foo defined").args.is_empty());
1152 }
1153
1154 #[test]
1155 fn unbraced_spaced_binds() {
1156 let db = db_of("\\newcommand \\foo[1]{x}\n");
1157 assert_eq!(db.command("foo").unwrap().args.len(), 1);
1158 }
1159
1160 #[test]
1161 fn unbraced_renewcommand() {
1162 let db = db_of("\\renewcommand\\foo[1]{x}\n");
1163 assert_eq!(db.command("foo").unwrap().args.len(), 1);
1164 }
1165
1166 #[test]
1167 fn unbraced_xparse_command() {
1168 let db = db_of("\\NewDocumentCommand\\foo{m O{d} m}{x}\n");
1169 let sig = db.command("foo").expect("foo defined");
1170 assert_eq!(
1171 arg_kinds(&sig.args),
1172 vec![ArgKind::Brace, ArgKind::Bracket, ArgKind::Brace]
1173 );
1174 }
1175
1176 #[test]
1177 fn unbraced_stray_text_not_bound() {
1178 let db = db_of("\\newcommand foo \\bar{x}\n");
1179 assert!(db.command("foo").is_none());
1180 assert!(db.command("bar").is_none());
1181 }
1182
1183 #[test]
1184 fn redefinition_last_wins() {
1185 let db = db_of("\\newcommand{\\foo}[1]{x}\\renewcommand{\\foo}[3]{y}\n");
1186 assert_eq!(db.command("foo").unwrap().args.len(), 3);
1187 }
1188
1189 #[test]
1190 fn garbage_definition_degrades_to_no_insert() {
1191 let db = db_of("\\newcommand\n");
1192 assert!(db.command("foo").is_none());
1193 }
1194
1195 #[test]
1196 fn nested_definition_collected() {
1197 let db = db_of("\\begin{document}\n\\newcommand{\\foo}[1]{x}\n\\end{document}\n");
1198 assert_eq!(db.command("foo").unwrap().args.len(), 1);
1199 }
1200
1201 #[test]
1202 fn commented_definition_ignored() {
1203 let db = db_of("% \\newcommand{\\foo}[1]{x}\n");
1204 assert!(db.command("foo").is_none());
1205 }
1206
1207 #[test]
1208 fn verbatim_makeother_flagged() {
1209 let db = db_of("\\newcommand\\shellcmd[1]{\\@makeother\\$#1}\n");
1210 let sig = db.command("shellcmd").expect("shellcmd defined");
1211 assert!(sig.verbatim);
1212 assert!(sig.args.is_empty());
1213 }
1214
1215 #[test]
1216 fn verbatim_catcode_flagged() {
1217 let db = db_of("\\newcommand\\shellcmd[1]{\\catcode 36=12 #1}\n");
1218 assert!(db.command("shellcmd").expect("shellcmd defined").verbatim);
1219 }
1220
1221 #[test]
1222 fn unrelated_twelve_does_not_flag_catcode_assignment() {
1223 let db = db_of("\\newcommand\\ordinary[1]{\\catcode 36=\\active \\hspace{12pt}#1}\n");
1224 assert!(!db.command("ordinary").expect("ordinary defined").verbatim);
1225 }
1226
1227 #[test]
1228 fn verbatim_dospecials_flagged() {
1229 let db = db_of("\\newcommand\\shellcmd[1]{\\let\\do\\@makeother\\dospecials #1}\n");
1230 assert!(db.command("shellcmd").expect("shellcmd defined").verbatim);
1231 }
1232
1233 #[test]
1234 fn verbatim_keeps_leading_args() {
1235 let db = db_of("\\newcommand\\mycode[2]{\\@makeother\\$#1#2}\n");
1236 let sig = db.command("mycode").expect("mycode defined");
1237 assert!(sig.verbatim);
1238 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Brace]);
1239 }
1240
1241 #[test]
1242 fn verbatim_via_chained_helper() {
1243 let db =
1244 db_of("\\newcommand\\setup{\\@makeother\\$}\\newcommand\\shellcmd[1]{\\setup#1}\n");
1245 assert!(db.command("shellcmd").expect("shellcmd defined").verbatim);
1246 assert!(!db.command("setup").expect("setup defined").verbatim);
1247 }
1248
1249 #[test]
1250 fn verbatim_chain_cycle_terminates() {
1251 let db = db_of("\\newcommand\\a[1]{\\b#1}\\newcommand\\b[1]{\\a#1}\n");
1252 assert!(!db.command("a").expect("a defined").verbatim);
1253 assert!(!db.command("b").expect("b defined").verbatim);
1254 }
1255
1256 #[test]
1257 fn ordinary_command_not_verbatim() {
1258 let db = db_of("\\newcommand\\foo[1]{\\emph{#1}}\n");
1259 assert!(!db.command("foo").expect("foo defined").verbatim);
1260 }
1261
1262 #[test]
1263 fn verbatim_needs_an_argument() {
1264 let db = db_of("\\newcommand\\setup{\\@makeother\\$}\n");
1265 assert!(!db.command("setup").expect("setup defined").verbatim);
1266 }
1267
1268 #[test]
1269 fn def_helper_chain_followed() {
1270 let db = db_of("\\def\\setup{\\@makeother\\$}\\newcommand\\shellcmd[1]{\\setup#1}\n");
1271 assert!(db.command("shellcmd").expect("shellcmd defined").verbatim);
1272 assert!(!db.command("setup").expect("setup defined").verbatim);
1273 }
1274
1275 #[test]
1276 fn def_direct_verbatim_flagged() {
1277 let db = db_of("\\def\\shellcmd#1{\\@makeother\\$#1}\n");
1278 let sig = db.command("shellcmd").expect("shellcmd defined");
1279 assert!(sig.verbatim);
1280 assert!(sig.args.is_empty());
1281 }
1282
1283 #[test]
1284 fn def_zero_params() {
1285 let db = db_of("\\def\\foo{x}\n");
1286 let sig = db.command("foo").expect("foo defined");
1287 assert!(sig.args.is_empty());
1288 assert!(!sig.verbatim);
1289 }
1290
1291 #[test]
1292 fn def_counts_params() {
1293 let db = db_of("\\def\\foo#1#2{#1#2}\n");
1294 let sig = db.command("foo").expect("foo defined");
1295 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Brace, ArgKind::Brace]);
1296 }
1297
1298 #[test]
1299 fn def_variants_scanned() {
1300 let db = db_of("\\edef\\a#1{x}\\gdef\\b{y}\\xdef\\c#1{\\@makeother\\$#1}\n");
1301 assert_eq!(db.command("a").expect("a defined").args.len(), 1);
1302 assert!(db.command("b").expect("b defined").args.is_empty());
1303 let c = db.command("c").expect("c defined");
1304 assert!(c.verbatim);
1305 assert!(c.args.is_empty());
1306 }
1307
1308 #[test]
1309 fn def_chain_through_def_helpers() {
1310 let db = db_of(
1311 "\\def\\inner{\\@makeother\\$}\\def\\outer{\\inner}\\newcommand\\cmd[1]{\\outer#1}\n",
1312 );
1313 assert!(db.command("cmd").expect("cmd defined").verbatim);
1314 }
1315
1316 #[test]
1317 fn verbatim_xparse_flagged() {
1318 let db = db_of("\\NewDocumentCommand\\shellcmd{m}{\\@makeother\\$#1}\n");
1319 let sig = db.command("shellcmd").expect("shellcmd defined");
1320 assert!(sig.verbatim);
1321 assert!(sig.args.is_empty());
1322 }
1323
1324 #[test]
1325 fn env_makeother_flagged() {
1326 let db = db_of("\\newenvironment{shellenv}{\\@makeother\\$}{}\n");
1327 let sig = db.environment("shellenv").expect("shellenv defined");
1328 assert!(sig.verbatim_body);
1329 assert!(!sig.reflow()); }
1331
1332 #[test]
1333 fn env_catcode_flagged() {
1334 let db = db_of("\\newenvironment{shellenv}[1]{\\catcode 36=12 }{}\n");
1335 let sig = db.environment("shellenv").expect("shellenv defined");
1336 assert!(sig.verbatim_body);
1337 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Brace]);
1338 }
1339
1340 #[test]
1341 fn env_via_chained_helper() {
1342 let db =
1343 db_of("\\newcommand\\setup{\\@makeother\\$}\\newenvironment{shellenv}{\\setup}{}\n");
1344 assert!(
1345 db.environment("shellenv")
1346 .expect("shellenv defined")
1347 .verbatim_body
1348 );
1349 }
1350
1351 #[test]
1352 fn env_without_signal_not_flagged() {
1353 let db = db_of("\\newenvironment{remark}{\\par\\noindent\\textbf{Remark.}}{\\par}\n");
1354 let sig = db.environment("remark").expect("remark defined");
1355 assert!(!sig.verbatim_body);
1356 assert!(sig.reflow());
1357 }
1358
1359 #[test]
1360 fn lstnewenvironment_flagged_verbatim() {
1361 let db = db_of("\\lstnewenvironment{demo}[1][code]{\\lstset{#1}}{}\n");
1362 let sig = db.environment("demo").expect("demo defined");
1363 assert!(sig.verbatim_body);
1364 assert!(!sig.reflow());
1365 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Bracket]);
1366 }
1367
1368 #[test]
1369 fn lstnewenvironment_no_args_flagged_verbatim() {
1370 let db = db_of("\\lstnewenvironment{demo}{}{}\n");
1371 let sig = db.environment("demo").expect("demo defined");
1372 assert!(sig.verbatim_body);
1373 assert!(sig.args.is_empty());
1374 }
1375
1376 #[test]
1377 fn defineverbatimenvironment_flagged_verbatim() {
1378 let db = db_of("\\DefineVerbatimEnvironment{code}{Verbatim}{fontsize=\\small}\n");
1379 let sig = db.environment("code").expect("code defined");
1380 assert!(sig.verbatim_body);
1381 assert!(!sig.reflow());
1382 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Bracket]);
1383 }
1384
1385 #[test]
1386 fn xparse_env_makeother_flagged() {
1387 let db = db_of("\\NewDocumentEnvironment{shellenv}{O{x}}{\\dospecials}{}\n");
1388 let sig = db.environment("shellenv").expect("shellenv defined");
1389 assert!(sig.verbatim_body);
1390 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Bracket]);
1391 }
1392
1393 fn sites_of(src: &str) -> Vec<DefSite> {
1394 assert_eq!(reconstruct(src), src, "reconstruct must round-trip");
1395 scan_definition_sites(&SyntaxNode::new_root(parse(src).green))
1396 }
1397
1398 #[test]
1399 fn def_site_newcommand_braced_name_span() {
1400 let src = "\\newcommand{\\foo}[1]{#1}\n";
1401 let sites = sites_of(src);
1402 assert_eq!(sites.len(), 1);
1403 let site = &sites[0];
1404 assert_eq!(site.name, "foo");
1405 assert_eq!(site.kind, DefSiteKind::Command);
1406 assert_eq!(&src[site.name_range], "\\foo");
1407 assert_eq!(&src[site.range], "\\newcommand{\\foo}[1]{#1}");
1408 }
1409
1410 #[test]
1411 fn def_site_newcommand_unbraced_name_span() {
1412 let src = "\\newcommand\\foo[1]{#1}\n";
1413 let sites = sites_of(src);
1414 assert_eq!(sites.len(), 1);
1415 assert_eq!(sites[0].name, "foo");
1416 assert_eq!(&src[sites[0].name_range], "\\foo");
1417 assert_eq!(&src[sites[0].range], "\\newcommand\\foo[1]{#1}");
1418 }
1419
1420 #[test]
1421 fn def_site_def_sibling_name_span() {
1422 let src = "\\def\\foo#1{#1}\n";
1423 let sites = sites_of(src);
1424 assert_eq!(sites.len(), 1);
1425 assert_eq!(sites[0].name, "foo");
1426 assert_eq!(sites[0].kind, DefSiteKind::Command);
1427 assert_eq!(&src[sites[0].name_range], "\\foo");
1428 }
1429
1430 #[test]
1431 fn def_site_xparse_command_name_span() {
1432 let src = "\\NewDocumentCommand{\\foo}{m O{d}}{x}\n";
1433 let sites = sites_of(src);
1434 assert_eq!(sites.len(), 1);
1435 assert_eq!(sites[0].name, "foo");
1436 assert_eq!(&src[sites[0].name_range], "\\foo");
1437 }
1438
1439 #[test]
1440 fn def_site_newenvironment_name_span() {
1441 let src = "\\newenvironment{myenv}{begin}{end}\n";
1442 let sites = sites_of(src);
1443 assert_eq!(sites.len(), 1);
1444 let site = &sites[0];
1445 assert_eq!(site.name, "myenv");
1446 assert_eq!(site.kind, DefSiteKind::Environment);
1447 assert_eq!(&src[site.name_range], "myenv");
1448 }
1449
1450 #[test]
1451 fn def_site_xparse_environment_name_span() {
1452 let src = "\\NewDocumentEnvironment{myenv}{m}{a}{b}\n";
1453 let sites = sites_of(src);
1454 assert_eq!(sites.len(), 1);
1455 assert_eq!(sites[0].name, "myenv");
1456 assert_eq!(sites[0].kind, DefSiteKind::Environment);
1457 assert_eq!(&src[sites[0].name_range], "myenv");
1458 }
1459
1460 #[test]
1461 fn def_site_keeps_every_redefinition() {
1462 let src = "\\newcommand{\\foo}{a}\n\\renewcommand{\\foo}{b}\n";
1463 let sites = sites_of(src);
1464 assert_eq!(sites.len(), 2);
1465 assert!(sites.iter().all(|s| s.name == "foo"));
1466 assert!(sites[0].name_range.start() < sites[1].name_range.start());
1467 }
1468
1469 #[test]
1470 fn def_site_none_for_malformed() {
1471 assert!(sites_of("\\newcommand\n").is_empty());
1472 assert!(sites_of("\\newenvironment{}{a}{b}\n").is_empty());
1473 }
1474
1475 const EQNARRAY_PAIR: &str =
1476 "\\newcommand{\\bea}{\\begin{eqnarray}}\n\\newcommand{\\eea}{\\end{eqnarray}}\n";
1477
1478 #[test]
1479 fn newcommand_env_alias_pair_is_recorded() {
1480 let db = db_of(EQNARRAY_PAIR);
1481 assert_eq!(db.env_begin_alias("bea"), Some("eqnarray"));
1482 assert_eq!(db.env_end_alias("eea"), Some("eqnarray"));
1483 assert_eq!(db.env_begin_alias("eea"), None);
1484 assert_eq!(db.env_end_alias("bea"), None);
1485 }
1486
1487 #[test]
1488 fn def_env_alias_pair_is_recorded() {
1489 let db = db_of("\\def\\bea{\\begin{eqnarray}}\n\\def\\eea{\\end{eqnarray}}\n");
1490 assert_eq!(db.env_begin_alias("bea"), Some("eqnarray"));
1491 assert_eq!(db.env_end_alias("eea"), Some("eqnarray"));
1492 }
1493
1494 #[test]
1495 fn xparse_env_alias_pair_is_recorded() {
1496 let db = db_of(
1497 "\\NewDocumentCommand{\\bea}{}{\\begin{eqnarray}}\n\
1498 \\NewDocumentCommand{\\eea}{}{\\end{eqnarray}}\n",
1499 );
1500 assert_eq!(db.env_begin_alias("bea"), Some("eqnarray"));
1501 assert_eq!(db.env_end_alias("eea"), Some("eqnarray"));
1502 }
1503
1504 #[test]
1505 fn env_alias_body_tolerates_trivia() {
1506 let db = db_of(
1507 "\\newcommand{\\bea}{ \\begin{eqnarray} }\n\\newcommand{\\eea}{% why\n\\end{eqnarray}}\n",
1508 );
1509 assert_eq!(db.env_begin_alias("bea"), Some("eqnarray"));
1510 assert_eq!(db.env_end_alias("eea"), Some("eqnarray"));
1511 }
1512
1513 #[test]
1514 fn a_lone_env_alias_half_is_recorded() {
1515 let db = db_of("\\newcommand{\\bea}{\\begin{eqnarray}}\n");
1516 assert_eq!(db.env_begin_alias("bea"), Some("eqnarray"));
1517 assert_eq!(db.env_end_alias("bea"), None);
1518
1519 let db = db_of("\\newcommand{\\eea}{\\end{eqnarray}}\n");
1520 assert_eq!(db.env_end_alias("eea"), Some("eqnarray"));
1521 assert_eq!(db.env_begin_alias("eea"), None);
1522 }
1523
1524 #[test]
1525 fn a_lone_half_still_obeys_every_target_rule() {
1526 assert_eq!(
1527 db_of("\\newcommand{\\bmy}{\\begin{notacuratedenv}}\n").env_begin_alias("bmy"),
1528 None
1529 );
1530 assert_eq!(
1531 db_of("\\newcommand{\\ev}{\\end{verbatim}}\n").env_end_alias("ev"),
1532 None
1533 );
1534 assert_eq!(
1535 db_of("\\newcommand{\\bt}{\\begin{tabular}}\n").env_begin_alias("bt"),
1536 None
1537 );
1538 assert_eq!(
1539 db_of("\\newcommand{\\bea}[1]{\\begin{eqnarray}}\n").env_begin_alias("bea"),
1540 None
1541 );
1542 }
1543
1544 #[test]
1545 fn env_alias_rejects_uncurated_target() {
1546 let db = db_of(
1547 "\\newcommand{\\bmy}{\\begin{notacuratedenv}}\n\
1548 \\newcommand{\\emy}{\\end{notacuratedenv}}\n",
1549 );
1550 assert_eq!(db.env_begin_alias("bmy"), None);
1551 assert_eq!(db.env_end_alias("emy"), None);
1552 }
1553
1554 #[test]
1555 fn env_alias_rejects_verbatim_target() {
1556 let db =
1557 db_of("\\newcommand{\\bv}{\\begin{verbatim}}\n\\newcommand{\\ev}{\\end{verbatim}}\n");
1558 assert_eq!(db.env_begin_alias("bv"), None);
1559 }
1560
1561 #[test]
1562 fn env_alias_rejects_argument_taking_target() {
1563 let db =
1564 db_of("\\newcommand{\\bt}{\\begin{tabular}}\n\\newcommand{\\et}{\\end{tabular}}\n");
1565 assert_eq!(db.env_begin_alias("bt"), None);
1566 }
1567
1568 #[test]
1569 fn env_alias_rejects_parameterized_definition() {
1570 let db = db_of(
1571 "\\newcommand{\\bt}[1]{\\begin{tabular}{#1}}\n\\newcommand{\\et}{\\end{tabular}}\n",
1572 );
1573 assert_eq!(db.env_begin_alias("bt"), None);
1574 }
1575
1576 #[test]
1577 fn env_alias_rejects_body_with_extra_content() {
1578 let db = db_of(
1579 "\\newcommand{\\bea}{\\begin{eqnarray}\\label{x}}\n\\newcommand{\\eea}{\\end{eqnarray}}\n",
1580 );
1581 assert_eq!(db.env_begin_alias("bea"), None);
1582 }
1583
1584 #[test]
1585 fn redefinition_retracts_an_earlier_env_alias() {
1586 let db = db_of(
1587 "\\newcommand{\\bea}{\\begin{eqnarray}}\n\
1588 \\newcommand{\\eea}{\\end{eqnarray}}\n\
1589 \\renewcommand{\\bea}{\\textbf}\n",
1590 );
1591 assert_eq!(db.env_begin_alias("bea"), None);
1592 }
1593
1594 #[test]
1595 fn env_alias_does_not_pollute_the_environment_namespace() {
1596 let db = db_of(EQNARRAY_PAIR);
1597 assert!(db.environment("bea").is_none());
1598 assert!(!db.environment_names().any(|n| n == "bea"));
1599 }
1600
1601 fn environment_node(src: &str) -> SyntaxNode {
1602 SyntaxNode::new_root(parse(src).green)
1603 .descendants()
1604 .find(|n| n.kind() == SyntaxKind::ENVIRONMENT)
1605 .expect("an environment")
1606 }
1607
1608 #[test]
1609 fn signatures_resolves_an_env_alias_to_the_curated_target() {
1610 use crate::semantic::signature::Signatures;
1611 let src = format!("{EQNARRAY_PAIR}\\bea a \\eea\n");
1612 let db = db_of(&src);
1613 let sigs = Signatures::new(&db);
1614 let sig = sigs
1615 .environment_at(&environment_node(&src))
1616 .expect("alias resolves");
1617 let target = builtin().environment("eqnarray").expect("curated target");
1618 assert_eq!(sig, target);
1619 assert!(sig.math && sig.align);
1620 assert!(sigs.environment("bea").is_none());
1621 }
1622
1623 #[test]
1624 fn a_literal_begin_does_not_inherit_the_alias_target() {
1625 use crate::semantic::signature::Signatures;
1626 let src = format!("{EQNARRAY_PAIR}\\begin{{bea}} a \\end{{bea}}\n");
1627 let db = db_of(&src);
1628 let sigs = Signatures::new(&db);
1629 assert!(sigs.environment_at(&environment_node(&src)).is_none());
1630 }
1631
1632 #[test]
1633 fn a_real_environment_wins_over_an_alias_of_the_same_name() {
1634 use crate::semantic::signature::Signatures;
1635 let defs = "\\newcommand{\\bea}{\\begin{eqnarray}}\n\
1636 \\newcommand{\\eea}{\\end{eqnarray}}\n\
1637 \\newenvironment{bea}{x}{y}\n";
1638 let db = db_of(&format!("{defs}\\begin{{bea}} a \\end{{bea}}\n"));
1639 let sigs = Signatures::new(&db);
1640 let sig = sigs
1641 .environment_at(&environment_node(&format!(
1642 "{defs}\\begin{{bea}} a \\end{{bea}}\n"
1643 )))
1644 .expect("real environment resolves");
1645 assert!(
1646 !sig.math,
1647 "the scanned \\newenvironment must win for a literal `\\begin{{bea}}`"
1648 );
1649 assert!(
1650 sigs.environment_at(&environment_node(&format!("{defs}\\bea a \\eea\n")))
1651 .is_some_and(|sig| sig.math),
1652 "while the alias delimiters still resolve to eqnarray"
1653 );
1654 }
1655
1656 #[test]
1657 fn merge_from_carries_env_aliases() {
1658 let mut target = SignatureDb::default();
1659 target.merge_from(&db_of(EQNARRAY_PAIR), None);
1660 assert_eq!(target.env_begin_alias("bea"), Some("eqnarray"));
1661 assert_eq!(target.env_end_alias("eea"), Some("eqnarray"));
1662 }
1663}