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