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 algorithm2e: false,
993 label_key: false,
995 caption_container: false,
997 align: false,
998 no_indent: false,
999 list: false,
1002 inline: false,
1003 block_explicit: false,
1007 outline: None,
1010 }
1011}
1012
1013const REFERENCE_PRIMITIVES: &[&str] = &["\\let", "\\ifx"];
1024
1025pub fn in_reference_position(command: &SyntaxNode) -> bool {
1032 let Some(control_word) = child_token::<ControlWord>(command) else {
1033 return false;
1034 };
1035 let mut token = control_word.syntax().prev_token();
1036 let mut control_words_seen = 0;
1037 while let Some(current) = token {
1038 match current.kind() {
1039 SyntaxKind::WHITESPACE
1045 | SyntaxKind::NEWLINE
1046 | SyntaxKind::COMMENT
1047 | SyntaxKind::WORD => {}
1048 SyntaxKind::CONTROL_WORD => {
1049 if REFERENCE_PRIMITIVES.contains(¤t.text()) {
1050 return true;
1051 }
1052 control_words_seen += 1;
1053 if control_words_seen >= 2 {
1054 return false;
1055 }
1056 }
1057 _ => return false,
1058 }
1059 token = current.prev_token();
1060 }
1061 false
1062}
1063
1064#[cfg(test)]
1065mod tests {
1066 use super::*;
1067 use crate::parser::{parse, reconstruct};
1068
1069 fn db_of(src: &str) -> SignatureDb {
1070 assert_eq!(reconstruct(src), src, "reconstruct must round-trip");
1071 scan_definitions(&SyntaxNode::new_root(parse(src).green))
1072 }
1073
1074 fn arg_kinds(args: &[ArgSpec]) -> Vec<ArgKind> {
1075 args.iter().map(|a| a.kind).collect()
1076 }
1077
1078 #[test]
1079 fn newcommand_counts_mandatory_args() {
1080 let db = db_of("\\newcommand{\\foo}[2]{#1#2}\n");
1081 let sig = db.command("foo").expect("foo defined");
1082 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Brace, ArgKind::Brace]);
1083 assert!(sig.args.iter().all(|a| a.required));
1084 assert!(
1085 sig.args
1086 .iter()
1087 .all(|arg| arg.domain == crate::semantic::ArgumentDomain::Unknown)
1088 );
1089 }
1090
1091 #[test]
1092 fn newcommand_optional_first_arg() {
1093 let db = db_of("\\newcommand{\\foo}[2][d]{#1#2}\n");
1094 let sig = db.command("foo").expect("foo defined");
1095 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Bracket, ArgKind::Brace]);
1096 assert!(!sig.args[0].required);
1097 assert!(sig.args[1].required);
1098 }
1099
1100 #[test]
1101 fn newcommand_zero_args() {
1102 let db = db_of("\\newcommand{\\foo}{bar}\n");
1103 assert!(db.command("foo").expect("foo defined").args.is_empty());
1104 }
1105
1106 #[test]
1107 fn renew_and_provide_recognized() {
1108 let db = db_of("\\renewcommand{\\a}[1]{x}\\providecommand{\\b}[1]{y}\n");
1109 assert_eq!(db.command("a").unwrap().args.len(), 1);
1110 assert_eq!(db.command("b").unwrap().args.len(), 1);
1111 }
1112
1113 #[test]
1114 fn secdef_redefinition_keeps_builtin_prose() {
1115 let db = db_of("\\renewcommand{\\section}{\\secdef \\a \\b}\n");
1116 assert!(
1117 db.command("section").is_none(),
1118 "the delegating redefinition must not be recorded as a scanned override"
1119 );
1120 let sigs = crate::semantic::signature::Signatures::new(&db);
1121 let sig = sigs.command("section").expect("built-in section survives");
1122 let last = sig.args.last().expect("section keeps its title argument");
1123 assert_eq!(
1124 last.content,
1125 crate::semantic::signature::ContentKind::Prose,
1126 "the title argument stays prose (reflowable)"
1127 );
1128 }
1129
1130 #[test]
1131 fn genuine_zero_arg_redefinition_downgrades_builtin() {
1132 let db = db_of("\\renewcommand{\\section}{\\textbf{Fixed}}\n");
1133 let sig = db
1134 .command("section")
1135 .expect("genuine 0-arg redefinition is recorded");
1136 assert!(
1137 sig.args.is_empty(),
1138 "no delegation means the scanned 0-arg signature wins"
1139 );
1140 }
1141
1142 #[test]
1143 fn secdef_redefinition_of_unknown_still_records() {
1144 let db = db_of("\\renewcommand{\\mysec}{\\secdef \\a \\b}\n");
1145 let sig = db.command("mysec").expect("unknown name is still recorded");
1146 assert!(sig.args.is_empty());
1147 }
1148
1149 #[test]
1150 fn newenvironment_args() {
1151 let db = db_of("\\newenvironment{thm}[1]{begin #1}{end}\n");
1152 let sig = db.environment("thm").expect("thm defined");
1153 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Brace]);
1154 assert!(sig.reflow());
1155 assert!(!sig.verbatim_body);
1156 assert!(!sig.math);
1157 }
1158
1159 #[test]
1160 fn xparse_command_spec() {
1161 let db = db_of("\\NewDocumentCommand{\\foo}{m O{d} m}{x}\n");
1162 let sig = db.command("foo").expect("foo defined");
1163 assert_eq!(
1164 arg_kinds(&sig.args),
1165 vec![ArgKind::Brace, ArgKind::Bracket, ArgKind::Brace]
1166 );
1167 assert!(
1168 sig.args
1169 .iter()
1170 .all(|arg| arg.domain == crate::semantic::ArgumentDomain::Unknown)
1171 );
1172 }
1173
1174 #[test]
1175 fn xparse_environment_spec() {
1176 let db = db_of("\\NewDocumentEnvironment{env}{O{x} m}{a}{b}\n");
1177 let sig = db.environment("env").expect("env defined");
1178 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Bracket, ArgKind::Brace]);
1179 assert!(
1180 sig.args
1181 .iter()
1182 .all(|arg| arg.domain == crate::semantic::ArgumentDomain::Unknown)
1183 );
1184 }
1185
1186 #[test]
1187 fn xparse_verbatim_body_spec() {
1188 for definer in [
1189 "NewDocumentEnvironment",
1190 "RenewDocumentEnvironment",
1191 "ProvideDocumentEnvironment",
1192 "DeclareDocumentEnvironment",
1193 ] {
1194 let db = db_of(&format!("\\{definer}{{demo}}{{O{{code}} c}}{{#2}}{{}}\n"));
1195 let sig = db.environment("demo").expect("demo defined");
1196 assert!(sig.verbatim_body, "{definer}");
1197 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Bracket]);
1198 }
1199 }
1200
1201 #[test]
1202 fn unbraced_newcommand_extracted() {
1203 let db = db_of("\\newcommand\\foo[2]{#1#2}\n");
1204 let sig = db.command("foo").expect("foo defined");
1205 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Brace, ArgKind::Brace]);
1206 assert!(sig.args.iter().all(|a| a.required));
1207 }
1208
1209 #[test]
1210 fn unbraced_optional_first_arg() {
1211 let db = db_of("\\newcommand\\foo[2][d]{#1#2}\n");
1212 let sig = db.command("foo").expect("foo defined");
1213 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Bracket, ArgKind::Brace]);
1214 assert!(!sig.args[0].required);
1215 assert!(sig.args[1].required);
1216 }
1217
1218 #[test]
1219 fn unbraced_zero_args() {
1220 let db = db_of("\\newcommand\\foo{x}\n");
1221 assert!(db.command("foo").expect("foo defined").args.is_empty());
1222 }
1223
1224 #[test]
1225 fn unbraced_spaced_binds() {
1226 let db = db_of("\\newcommand \\foo[1]{x}\n");
1227 assert_eq!(db.command("foo").unwrap().args.len(), 1);
1228 }
1229
1230 #[test]
1231 fn unbraced_renewcommand() {
1232 let db = db_of("\\renewcommand\\foo[1]{x}\n");
1233 assert_eq!(db.command("foo").unwrap().args.len(), 1);
1234 }
1235
1236 #[test]
1237 fn unbraced_xparse_command() {
1238 let db = db_of("\\NewDocumentCommand\\foo{m O{d} m}{x}\n");
1239 let sig = db.command("foo").expect("foo defined");
1240 assert_eq!(
1241 arg_kinds(&sig.args),
1242 vec![ArgKind::Brace, ArgKind::Bracket, ArgKind::Brace]
1243 );
1244 }
1245
1246 #[test]
1247 fn unbraced_stray_text_not_bound() {
1248 let db = db_of("\\newcommand foo \\bar{x}\n");
1249 assert!(db.command("foo").is_none());
1250 assert!(db.command("bar").is_none());
1251 }
1252
1253 #[test]
1254 fn redefinition_last_wins() {
1255 let db = db_of("\\newcommand{\\foo}[1]{x}\\renewcommand{\\foo}[3]{y}\n");
1256 assert_eq!(db.command("foo").unwrap().args.len(), 3);
1257 }
1258
1259 #[test]
1260 fn garbage_definition_degrades_to_no_insert() {
1261 let db = db_of("\\newcommand\n");
1262 assert!(db.command("foo").is_none());
1263 }
1264
1265 #[test]
1266 fn nested_definition_collected() {
1267 let db = db_of("\\begin{document}\n\\newcommand{\\foo}[1]{x}\n\\end{document}\n");
1268 assert_eq!(db.command("foo").unwrap().args.len(), 1);
1269 }
1270
1271 #[test]
1272 fn commented_definition_ignored() {
1273 let db = db_of("% \\newcommand{\\foo}[1]{x}\n");
1274 assert!(db.command("foo").is_none());
1275 }
1276
1277 #[test]
1278 fn verbatim_makeother_flagged() {
1279 let db = db_of("\\newcommand\\shellcmd[1]{\\@makeother\\$#1}\n");
1280 let sig = db.command("shellcmd").expect("shellcmd defined");
1281 assert!(sig.verbatim);
1282 assert!(sig.args.is_empty());
1283 }
1284
1285 #[test]
1286 fn verbatim_catcode_flagged() {
1287 let db = db_of("\\newcommand\\shellcmd[1]{\\catcode 36=12 #1}\n");
1288 assert!(db.command("shellcmd").expect("shellcmd defined").verbatim);
1289 }
1290
1291 #[test]
1292 fn unrelated_twelve_does_not_flag_catcode_assignment() {
1293 let db = db_of("\\newcommand\\ordinary[1]{\\catcode 36=\\active \\hspace{12pt}#1}\n");
1294 assert!(!db.command("ordinary").expect("ordinary defined").verbatim);
1295 }
1296
1297 #[test]
1298 fn verbatim_dospecials_flagged() {
1299 let db = db_of("\\newcommand\\shellcmd[1]{\\let\\do\\@makeother\\dospecials #1}\n");
1300 assert!(db.command("shellcmd").expect("shellcmd defined").verbatim);
1301 }
1302
1303 #[test]
1304 fn verbatim_keeps_leading_args() {
1305 let db = db_of("\\newcommand\\mycode[2]{\\@makeother\\$#1#2}\n");
1306 let sig = db.command("mycode").expect("mycode defined");
1307 assert!(sig.verbatim);
1308 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Brace]);
1309 }
1310
1311 #[test]
1312 fn verbatim_via_chained_helper() {
1313 let db =
1314 db_of("\\newcommand\\setup{\\@makeother\\$}\\newcommand\\shellcmd[1]{\\setup#1}\n");
1315 assert!(db.command("shellcmd").expect("shellcmd defined").verbatim);
1316 assert!(!db.command("setup").expect("setup defined").verbatim);
1317 }
1318
1319 #[test]
1320 fn verbatim_chain_cycle_terminates() {
1321 let db = db_of("\\newcommand\\a[1]{\\b#1}\\newcommand\\b[1]{\\a#1}\n");
1322 assert!(!db.command("a").expect("a defined").verbatim);
1323 assert!(!db.command("b").expect("b defined").verbatim);
1324 }
1325
1326 #[test]
1327 fn ordinary_command_not_verbatim() {
1328 let db = db_of("\\newcommand\\foo[1]{\\emph{#1}}\n");
1329 assert!(!db.command("foo").expect("foo defined").verbatim);
1330 }
1331
1332 #[test]
1333 fn verbatim_needs_an_argument() {
1334 let db = db_of("\\newcommand\\setup{\\@makeother\\$}\n");
1335 assert!(!db.command("setup").expect("setup defined").verbatim);
1336 }
1337
1338 #[test]
1339 fn def_helper_chain_followed() {
1340 let db = db_of("\\def\\setup{\\@makeother\\$}\\newcommand\\shellcmd[1]{\\setup#1}\n");
1341 assert!(db.command("shellcmd").expect("shellcmd defined").verbatim);
1342 assert!(!db.command("setup").expect("setup defined").verbatim);
1343 }
1344
1345 #[test]
1346 fn def_direct_verbatim_flagged() {
1347 let db = db_of("\\def\\shellcmd#1{\\@makeother\\$#1}\n");
1348 let sig = db.command("shellcmd").expect("shellcmd defined");
1349 assert!(sig.verbatim);
1350 assert!(sig.args.is_empty());
1351 }
1352
1353 #[test]
1354 fn def_zero_params() {
1355 let db = db_of("\\def\\foo{x}\n");
1356 let sig = db.command("foo").expect("foo defined");
1357 assert!(sig.args.is_empty());
1358 assert!(!sig.verbatim);
1359 }
1360
1361 #[test]
1362 fn def_counts_params() {
1363 let db = db_of("\\def\\foo#1#2{#1#2}\n");
1364 let sig = db.command("foo").expect("foo defined");
1365 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Brace, ArgKind::Brace]);
1366 }
1367
1368 #[test]
1369 fn def_variants_scanned() {
1370 let db = db_of("\\edef\\a#1{x}\\gdef\\b{y}\\xdef\\c#1{\\@makeother\\$#1}\n");
1371 assert_eq!(db.command("a").expect("a defined").args.len(), 1);
1372 assert!(db.command("b").expect("b defined").args.is_empty());
1373 let c = db.command("c").expect("c defined");
1374 assert!(c.verbatim);
1375 assert!(c.args.is_empty());
1376 }
1377
1378 #[test]
1379 fn def_chain_through_def_helpers() {
1380 let db = db_of(
1381 "\\def\\inner{\\@makeother\\$}\\def\\outer{\\inner}\\newcommand\\cmd[1]{\\outer#1}\n",
1382 );
1383 assert!(db.command("cmd").expect("cmd defined").verbatim);
1384 }
1385
1386 #[test]
1387 fn verbatim_xparse_flagged() {
1388 let db = db_of("\\NewDocumentCommand\\shellcmd{m}{\\@makeother\\$#1}\n");
1389 let sig = db.command("shellcmd").expect("shellcmd defined");
1390 assert!(sig.verbatim);
1391 assert!(sig.args.is_empty());
1392 }
1393
1394 #[test]
1395 fn env_makeother_flagged() {
1396 let db = db_of("\\newenvironment{shellenv}{\\@makeother\\$}{}\n");
1397 let sig = db.environment("shellenv").expect("shellenv defined");
1398 assert!(sig.verbatim_body);
1399 assert!(!sig.reflow()); }
1401
1402 #[test]
1403 fn env_catcode_flagged() {
1404 let db = db_of("\\newenvironment{shellenv}[1]{\\catcode 36=12 }{}\n");
1405 let sig = db.environment("shellenv").expect("shellenv defined");
1406 assert!(sig.verbatim_body);
1407 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Brace]);
1408 }
1409
1410 #[test]
1411 fn env_via_chained_helper() {
1412 let db =
1413 db_of("\\newcommand\\setup{\\@makeother\\$}\\newenvironment{shellenv}{\\setup}{}\n");
1414 assert!(
1415 db.environment("shellenv")
1416 .expect("shellenv defined")
1417 .verbatim_body
1418 );
1419 }
1420
1421 #[test]
1422 fn env_without_signal_not_flagged() {
1423 let db = db_of("\\newenvironment{remark}{\\par\\noindent\\textbf{Remark.}}{\\par}\n");
1424 let sig = db.environment("remark").expect("remark defined");
1425 assert!(!sig.verbatim_body);
1426 assert!(sig.reflow());
1427 }
1428
1429 #[test]
1430 fn lstnewenvironment_flagged_verbatim() {
1431 let db = db_of("\\lstnewenvironment{demo}[1][code]{\\lstset{#1}}{}\n");
1432 let sig = db.environment("demo").expect("demo defined");
1433 assert!(sig.verbatim_body);
1434 assert!(!sig.reflow());
1435 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Bracket]);
1436 }
1437
1438 #[test]
1439 fn lstnewenvironment_no_args_flagged_verbatim() {
1440 let db = db_of("\\lstnewenvironment{demo}{}{}\n");
1441 let sig = db.environment("demo").expect("demo defined");
1442 assert!(sig.verbatim_body);
1443 assert!(sig.args.is_empty());
1444 }
1445
1446 #[test]
1447 fn defineverbatimenvironment_flagged_verbatim() {
1448 let db = db_of("\\DefineVerbatimEnvironment{code}{Verbatim}{fontsize=\\small}\n");
1449 let sig = db.environment("code").expect("code defined");
1450 assert!(sig.verbatim_body);
1451 assert!(!sig.reflow());
1452 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Bracket]);
1453 }
1454
1455 #[test]
1456 fn xparse_env_makeother_flagged() {
1457 let db = db_of("\\NewDocumentEnvironment{shellenv}{O{x}}{\\dospecials}{}\n");
1458 let sig = db.environment("shellenv").expect("shellenv defined");
1459 assert!(sig.verbatim_body);
1460 assert_eq!(arg_kinds(&sig.args), vec![ArgKind::Bracket]);
1461 }
1462
1463 fn sites_of(src: &str) -> Vec<DefSite> {
1464 assert_eq!(reconstruct(src), src, "reconstruct must round-trip");
1465 scan_definition_sites(&SyntaxNode::new_root(parse(src).green))
1466 }
1467
1468 #[test]
1469 fn def_site_newcommand_braced_name_span() {
1470 let src = "\\newcommand{\\foo}[1]{#1}\n";
1471 let sites = sites_of(src);
1472 assert_eq!(sites.len(), 1);
1473 let site = &sites[0];
1474 assert_eq!(site.name, "foo");
1475 assert_eq!(site.kind, DefSiteKind::Command);
1476 assert_eq!(&src[site.name_range], "\\foo");
1477 assert_eq!(&src[site.range], "\\newcommand{\\foo}[1]{#1}");
1478 }
1479
1480 #[test]
1481 fn def_site_newcommand_unbraced_name_span() {
1482 let src = "\\newcommand\\foo[1]{#1}\n";
1483 let sites = sites_of(src);
1484 assert_eq!(sites.len(), 1);
1485 assert_eq!(sites[0].name, "foo");
1486 assert_eq!(&src[sites[0].name_range], "\\foo");
1487 assert_eq!(&src[sites[0].range], "\\newcommand\\foo[1]{#1}");
1488 }
1489
1490 #[test]
1491 fn def_site_def_sibling_name_span() {
1492 let src = "\\def\\foo#1{#1}\n";
1493 let sites = sites_of(src);
1494 assert_eq!(sites.len(), 1);
1495 assert_eq!(sites[0].name, "foo");
1496 assert_eq!(sites[0].kind, DefSiteKind::Command);
1497 assert_eq!(&src[sites[0].name_range], "\\foo");
1498 }
1499
1500 #[test]
1501 fn def_site_xparse_command_name_span() {
1502 let src = "\\NewDocumentCommand{\\foo}{m O{d}}{x}\n";
1503 let sites = sites_of(src);
1504 assert_eq!(sites.len(), 1);
1505 assert_eq!(sites[0].name, "foo");
1506 assert_eq!(&src[sites[0].name_range], "\\foo");
1507 }
1508
1509 #[test]
1510 fn def_site_newenvironment_name_span() {
1511 let src = "\\newenvironment{myenv}{begin}{end}\n";
1512 let sites = sites_of(src);
1513 assert_eq!(sites.len(), 1);
1514 let site = &sites[0];
1515 assert_eq!(site.name, "myenv");
1516 assert_eq!(site.kind, DefSiteKind::Environment);
1517 assert_eq!(&src[site.name_range], "myenv");
1518 }
1519
1520 #[test]
1521 fn def_site_xparse_environment_name_span() {
1522 let src = "\\NewDocumentEnvironment{myenv}{m}{a}{b}\n";
1523 let sites = sites_of(src);
1524 assert_eq!(sites.len(), 1);
1525 assert_eq!(sites[0].name, "myenv");
1526 assert_eq!(sites[0].kind, DefSiteKind::Environment);
1527 assert_eq!(&src[sites[0].name_range], "myenv");
1528 }
1529
1530 #[test]
1531 fn def_site_keeps_every_redefinition() {
1532 let src = "\\newcommand{\\foo}{a}\n\\renewcommand{\\foo}{b}\n";
1533 let sites = sites_of(src);
1534 assert_eq!(sites.len(), 2);
1535 assert!(sites.iter().all(|s| s.name == "foo"));
1536 assert!(sites[0].name_range.start() < sites[1].name_range.start());
1537 }
1538
1539 #[test]
1540 fn def_site_none_for_malformed() {
1541 assert!(sites_of("\\newcommand\n").is_empty());
1542 assert!(sites_of("\\newenvironment{}{a}{b}\n").is_empty());
1543 }
1544
1545 const EQNARRAY_PAIR: &str =
1546 "\\newcommand{\\bea}{\\begin{eqnarray}}\n\\newcommand{\\eea}{\\end{eqnarray}}\n";
1547
1548 #[test]
1549 fn newcommand_env_alias_pair_is_recorded() {
1550 let db = db_of(EQNARRAY_PAIR);
1551 assert_eq!(db.env_begin_alias("bea"), Some("eqnarray"));
1552 assert_eq!(db.env_end_alias("eea"), Some("eqnarray"));
1553 assert_eq!(db.env_begin_alias("eea"), None);
1554 assert_eq!(db.env_end_alias("bea"), None);
1555 }
1556
1557 #[test]
1558 fn def_env_alias_pair_is_recorded() {
1559 let db = db_of("\\def\\bea{\\begin{eqnarray}}\n\\def\\eea{\\end{eqnarray}}\n");
1560 assert_eq!(db.env_begin_alias("bea"), Some("eqnarray"));
1561 assert_eq!(db.env_end_alias("eea"), Some("eqnarray"));
1562 }
1563
1564 #[test]
1565 fn xparse_env_alias_pair_is_recorded() {
1566 let db = db_of(
1567 "\\NewDocumentCommand{\\bea}{}{\\begin{eqnarray}}\n\
1568 \\NewDocumentCommand{\\eea}{}{\\end{eqnarray}}\n",
1569 );
1570 assert_eq!(db.env_begin_alias("bea"), Some("eqnarray"));
1571 assert_eq!(db.env_end_alias("eea"), Some("eqnarray"));
1572 }
1573
1574 #[test]
1575 fn env_alias_body_tolerates_trivia() {
1576 let db = db_of(
1577 "\\newcommand{\\bea}{ \\begin{eqnarray} }\n\\newcommand{\\eea}{% why\n\\end{eqnarray}}\n",
1578 );
1579 assert_eq!(db.env_begin_alias("bea"), Some("eqnarray"));
1580 assert_eq!(db.env_end_alias("eea"), Some("eqnarray"));
1581 }
1582
1583 #[test]
1584 fn a_lone_env_alias_half_is_recorded() {
1585 let db = db_of("\\newcommand{\\bea}{\\begin{eqnarray}}\n");
1586 assert_eq!(db.env_begin_alias("bea"), Some("eqnarray"));
1587 assert_eq!(db.env_end_alias("bea"), None);
1588
1589 let db = db_of("\\newcommand{\\eea}{\\end{eqnarray}}\n");
1590 assert_eq!(db.env_end_alias("eea"), Some("eqnarray"));
1591 assert_eq!(db.env_begin_alias("eea"), None);
1592 }
1593
1594 #[test]
1595 fn a_lone_half_still_obeys_every_target_rule() {
1596 assert_eq!(
1597 db_of("\\newcommand{\\bmy}{\\begin{notacuratedenv}}\n").env_begin_alias("bmy"),
1598 None
1599 );
1600 assert_eq!(
1601 db_of("\\newcommand{\\ev}{\\end{verbatim}}\n").env_end_alias("ev"),
1602 None
1603 );
1604 assert_eq!(
1605 db_of("\\newcommand{\\bt}{\\begin{tabular}}\n").env_begin_alias("bt"),
1606 None
1607 );
1608 assert_eq!(
1609 db_of("\\newcommand{\\bea}[1]{\\begin{eqnarray}}\n").env_begin_alias("bea"),
1610 None
1611 );
1612 }
1613
1614 #[test]
1615 fn env_alias_rejects_uncurated_target() {
1616 let db = db_of(
1617 "\\newcommand{\\bmy}{\\begin{notacuratedenv}}\n\
1618 \\newcommand{\\emy}{\\end{notacuratedenv}}\n",
1619 );
1620 assert_eq!(db.env_begin_alias("bmy"), None);
1621 assert_eq!(db.env_end_alias("emy"), None);
1622 }
1623
1624 #[test]
1625 fn env_alias_rejects_verbatim_target() {
1626 let db =
1627 db_of("\\newcommand{\\bv}{\\begin{verbatim}}\n\\newcommand{\\ev}{\\end{verbatim}}\n");
1628 assert_eq!(db.env_begin_alias("bv"), None);
1629 }
1630
1631 #[test]
1632 fn env_alias_rejects_argument_taking_target() {
1633 let db =
1634 db_of("\\newcommand{\\bt}{\\begin{tabular}}\n\\newcommand{\\et}{\\end{tabular}}\n");
1635 assert_eq!(db.env_begin_alias("bt"), None);
1636 }
1637
1638 #[test]
1639 fn env_alias_rejects_parameterized_definition() {
1640 let db = db_of(
1641 "\\newcommand{\\bt}[1]{\\begin{tabular}{#1}}\n\\newcommand{\\et}{\\end{tabular}}\n",
1642 );
1643 assert_eq!(db.env_begin_alias("bt"), None);
1644 }
1645
1646 #[test]
1647 fn env_alias_rejects_body_with_extra_content() {
1648 let db = db_of(
1649 "\\newcommand{\\bea}{\\begin{eqnarray}\\label{x}}\n\\newcommand{\\eea}{\\end{eqnarray}}\n",
1650 );
1651 assert_eq!(db.env_begin_alias("bea"), None);
1652 }
1653
1654 #[test]
1655 fn redefinition_retracts_an_earlier_env_alias() {
1656 let db = db_of(
1657 "\\newcommand{\\bea}{\\begin{eqnarray}}\n\
1658 \\newcommand{\\eea}{\\end{eqnarray}}\n\
1659 \\renewcommand{\\bea}{\\textbf}\n",
1660 );
1661 assert_eq!(db.env_begin_alias("bea"), None);
1662 }
1663
1664 #[test]
1665 fn env_alias_does_not_pollute_the_environment_namespace() {
1666 let db = db_of(EQNARRAY_PAIR);
1667 assert!(db.environment("bea").is_none());
1668 assert!(!db.environment_names().any(|n| n == "bea"));
1669 }
1670
1671 fn environment_node(src: &str) -> SyntaxNode {
1672 SyntaxNode::new_root(parse(src).green)
1673 .descendants()
1674 .find(|n| n.kind() == SyntaxKind::ENVIRONMENT)
1675 .expect("an environment")
1676 }
1677
1678 #[test]
1679 fn signatures_resolves_an_env_alias_to_the_curated_target() {
1680 use crate::semantic::signature::Signatures;
1681 let src = format!("{EQNARRAY_PAIR}\\bea a \\eea\n");
1682 let db = db_of(&src);
1683 let sigs = Signatures::new(&db);
1684 let sig = sigs
1685 .environment_at(&environment_node(&src))
1686 .expect("alias resolves");
1687 let target = builtin().environment("eqnarray").expect("curated target");
1688 assert_eq!(sig, target);
1689 assert!(sig.math && sig.align);
1690 assert!(sigs.environment("bea").is_none());
1691 }
1692
1693 #[test]
1694 fn a_literal_begin_does_not_inherit_the_alias_target() {
1695 use crate::semantic::signature::Signatures;
1696 let src = format!("{EQNARRAY_PAIR}\\begin{{bea}} a \\end{{bea}}\n");
1697 let db = db_of(&src);
1698 let sigs = Signatures::new(&db);
1699 assert!(sigs.environment_at(&environment_node(&src)).is_none());
1700 }
1701
1702 #[test]
1703 fn a_real_environment_wins_over_an_alias_of_the_same_name() {
1704 use crate::semantic::signature::Signatures;
1705 let defs = "\\newcommand{\\bea}{\\begin{eqnarray}}\n\
1706 \\newcommand{\\eea}{\\end{eqnarray}}\n\
1707 \\newenvironment{bea}{x}{y}\n";
1708 let db = db_of(&format!("{defs}\\begin{{bea}} a \\end{{bea}}\n"));
1709 let sigs = Signatures::new(&db);
1710 let sig = sigs
1711 .environment_at(&environment_node(&format!(
1712 "{defs}\\begin{{bea}} a \\end{{bea}}\n"
1713 )))
1714 .expect("real environment resolves");
1715 assert!(
1716 !sig.math,
1717 "the scanned \\newenvironment must win for a literal `\\begin{{bea}}`"
1718 );
1719 assert!(
1720 sigs.environment_at(&environment_node(&format!("{defs}\\bea a \\eea\n")))
1721 .is_some_and(|sig| sig.math),
1722 "while the alias delimiters still resolve to eqnarray"
1723 );
1724 }
1725
1726 #[test]
1727 fn merge_from_carries_env_aliases() {
1728 let mut target = SignatureDb::default();
1729 target.merge_from(&db_of(EQNARRAY_PAIR), None);
1730 assert_eq!(target.env_begin_alias("bea"), Some("eqnarray"));
1731 assert_eq!(target.env_end_alias("eea"), Some("eqnarray"));
1732 }
1733}