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