1use std::path::Path;
56
57use oxc_allocator::Allocator;
58use oxc_ast::ast::*;
59use oxc_ast_visit::{Visit, walk};
60use oxc_parser::Parser;
61use oxc_semantic::ScopeFlags;
62use oxc_span::{SourceType, Span};
63use rustc_hash::FxHashMap;
64
65use crate::js_text::JsText;
66
67#[derive(Debug, Clone, PartialEq, Eq)]
78pub struct InventoryEntry {
79 pub name: String,
81 pub line: u32,
83 pub start_column: u32,
85 pub end_line: u32,
87 pub end_column: u32,
89 pub source_hash: Option<String>,
99 pub is_callback: bool,
104}
105
106#[derive(Clone, Copy)]
110struct ColCache {
111 line_idx: usize,
112 byte_end: usize,
113 utf16_units: usize,
114}
115
116impl ColCache {
117 const EMPTY: Self = Self {
118 line_idx: usize::MAX,
119 byte_end: 0,
120 utf16_units: 0,
121 };
122}
123
124#[cfg(test)]
125thread_local! {
126 static UTF16_BYTES: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
128}
129
130#[cfg(test)]
133fn take_utf16_bytes() -> usize {
134 UTF16_BYTES.with(|encoded| encoded.replace(0))
135}
136
137struct OpenFunction {
139 entry: usize,
141 span: Span,
142 height: u32,
144}
145
146struct ResolvedName {
148 name: String,
149 is_callback: bool,
151}
152
153impl ResolvedName {
154 const fn named(name: String) -> Self {
155 Self {
156 name,
157 is_callback: false,
158 }
159 }
160}
161
162struct InventoryVisitor<'a> {
164 source: &'a str,
165 line_offsets: &'a [u32],
166 entries: Vec<InventoryEntry>,
167 start_cols: ColCache,
170 end_cols: ColCache,
171 open: Vec<OpenFunction>,
173 inferred_names: FxHashMap<u32, String>,
179 callback_names: FxHashMap<u32, String>,
183 anonymous_counter: u32,
185}
186
187impl<'a> InventoryVisitor<'a> {
188 fn new(source: &'a str, line_offsets: &'a [u32]) -> Self {
189 Self {
190 source,
191 line_offsets,
192 entries: Vec::new(),
193 start_cols: ColCache::EMPTY,
194 end_cols: ColCache::EMPTY,
195 open: Vec::new(),
196 inferred_names: FxHashMap::default(),
197 callback_names: FxHashMap::default(),
198 anonymous_counter: 0,
199 }
200 }
201
202 fn resolve_name(&mut self, start: u32, explicit: Option<&str>) -> ResolvedName {
216 let n = self.anonymous_counter;
217 self.anonymous_counter += 1;
218 let inferred = self.inferred_names.remove(&start);
219 let callee = self.callback_names.remove(&start);
220 if let Some(name) = explicit {
221 return ResolvedName::named(name.to_owned());
222 }
223 if let Some(inferred) = inferred {
224 return ResolvedName::named(inferred);
225 }
226 if let Some(callee) = callee {
227 return ResolvedName {
228 name: callee,
229 is_callback: true,
230 };
231 }
232 ResolvedName::named(format!("(anonymous_{n})"))
233 }
234
235 fn infer_name_for_value(&mut self, value: &Expression<'_>, name: Option<String>) {
239 let Some(name) = name else { return };
240 if let Some(start) = function_value_start(value) {
241 self.inferred_names.insert(start, name);
242 }
243 }
244
245 fn name_callback_arguments(&mut self, callee: &Expression<'_>, arguments: &[Argument<'_>]) {
250 let Some(name) = callee_name(callee) else {
251 return;
252 };
253 for argument in arguments {
254 if let Some(start) = argument.as_expression().and_then(function_value_start) {
255 self.callback_names.insert(start, name.clone());
256 }
257 }
258 }
259
260 fn record(&mut self, resolved: ResolvedName, span: Span) {
261 let mut start_cols = self.start_cols;
262 let (line, start_column) = self.line_col_utf16(&mut start_cols, span.start);
263 self.start_cols = start_cols;
264 let mut end_cols = self.end_cols;
265 let (end_line, end_column) = self.line_col_utf16(&mut end_cols, span.end);
266 self.end_cols = end_cols;
267 self.open.push(OpenFunction {
268 entry: self.entries.len(),
269 span,
270 height: 0,
271 });
272 self.entries.push(InventoryEntry {
273 name: resolved.name,
274 line,
275 start_column,
276 end_line,
277 end_column,
278 source_hash: None,
279 is_callback: resolved.is_callback,
280 });
281 }
282
283 fn leave_function(&mut self) {
285 let Some(open) = self.open.pop() else {
286 return;
287 };
288 self.entries[open.entry].source_hash =
289 crate::function_hash::function_source_hash(self.source, open.span, open.height);
290 if let Some(parent) = self.open.last_mut() {
291 parent.height = parent.height.max(open.height + 1);
292 }
293 }
294
295 fn line_col_utf16(&self, cache: &mut ColCache, byte_offset: u32) -> (u32, u32) {
310 let line_idx = match self.line_offsets.binary_search(&byte_offset) {
311 Ok(idx) => idx,
312 Err(idx) => idx.saturating_sub(1),
313 };
314 let line = line_idx as u32 + 1;
315 let line_start = self.line_offsets[line_idx] as usize;
316 let mut end = byte_offset as usize;
317 while end > line_start && !self.source.is_char_boundary(end) {
318 end -= 1;
319 }
320 let from_cache = if cache.line_idx == line_idx {
324 if end >= cache.byte_end {
325 self.utf16_len(cache.byte_end, end)
326 .map(|gap| cache.utf16_units + gap)
327 } else {
328 self.utf16_len(end, cache.byte_end)
329 .map(|gap| cache.utf16_units - gap)
330 }
331 } else {
332 None
333 };
334 let col_utf16 = from_cache.unwrap_or_else(|| self.utf16_len(line_start, end).unwrap_or(0));
335 *cache = ColCache {
336 line_idx,
337 byte_end: end,
338 utf16_units: col_utf16,
339 };
340 (line, col_utf16 as u32 + 1)
341 }
342
343 fn utf16_len(&self, start: usize, end: usize) -> Option<usize> {
346 let slice = self.source.get(start..end)?;
347 #[cfg(test)]
348 UTF16_BYTES.with(|encoded| encoded.set(encoded.get() + slice.len()));
349 Some(slice.encode_utf16().count())
350 }
351}
352
353impl<'ast> Visit<'ast> for InventoryVisitor<'_> {
354 fn visit_function(&mut self, func: &Function<'ast>, flags: ScopeFlags) {
355 if func.body.is_none() {
356 walk::walk_function(self, func, flags);
357 return;
358 }
359 let resolved =
360 self.resolve_name(func.span.start, func.id.as_ref().map(|id| id.name.as_str()));
361 self.record(resolved, func.span);
362 walk::walk_function(self, func, flags);
363 self.leave_function();
364 }
365
366 fn visit_arrow_function_expression(&mut self, arrow: &ArrowFunctionExpression<'ast>) {
367 let resolved = self.resolve_name(arrow.span.start, None);
368 self.record(resolved, arrow.span);
369 walk::walk_arrow_function_expression(self, arrow);
370 self.leave_function();
371 }
372
373 fn visit_method_definition(&mut self, method: &MethodDefinition<'ast>) {
374 if let Some(name) = method.key.static_name() {
375 self.inferred_names.insert(
376 method.value.span.start,
377 accessor_label(
378 matches!(method.kind, MethodDefinitionKind::Get),
379 matches!(method.kind, MethodDefinitionKind::Set),
380 &name.text(),
381 ),
382 );
383 }
384 walk::walk_method_definition(self, method);
385 }
386
387 fn visit_variable_declarator(&mut self, decl: &VariableDeclarator<'ast>) {
388 if let Some(init) = &decl.init {
389 let name = decl
390 .id
391 .get_binding_identifier()
392 .map(|id| id.name.to_string());
393 self.infer_name_for_value(init, name);
394 }
395 walk::walk_variable_declarator(self, decl);
396 }
397
398 fn visit_object_property(&mut self, prop: &ObjectProperty<'ast>) {
405 let name = prop.key.static_name().map(|name| {
406 accessor_label(
407 matches!(prop.kind, PropertyKind::Get),
408 matches!(prop.kind, PropertyKind::Set),
409 &name.text(),
410 )
411 });
412 self.infer_name_for_value(&prop.value, name);
413 walk::walk_object_property(self, prop);
414 }
415
416 fn visit_assignment_expression(&mut self, expr: &AssignmentExpression<'ast>) {
427 if matches!(expr.operator, AssignmentOperator::Assign) {
428 self.infer_name_for_value(&expr.right, assignment_target_name(&expr.left));
429 }
430 walk::walk_assignment_expression(self, expr);
431 }
432
433 fn visit_formal_parameter(&mut self, param: &FormalParameter<'ast>) {
437 if let Some(init) = ¶m.initializer {
438 let name = param
439 .pattern
440 .get_binding_identifier()
441 .map(|id| id.name.to_string());
442 self.infer_name_for_value(init, name);
443 }
444 walk::walk_formal_parameter(self, param);
445 }
446
447 fn visit_assignment_pattern(&mut self, pattern: &AssignmentPattern<'ast>) {
451 let name = pattern
452 .left
453 .get_binding_identifier()
454 .map(|id| id.name.to_string());
455 self.infer_name_for_value(&pattern.right, name);
456 walk::walk_assignment_pattern(self, pattern);
457 }
458
459 fn visit_assignment_target_with_default(&mut self, target: &AssignmentTargetWithDefault<'ast>) {
463 if let AssignmentTarget::AssignmentTargetIdentifier(id) = &target.binding {
464 self.infer_name_for_value(&target.init, Some(id.name.to_string()));
465 }
466 walk::walk_assignment_target_with_default(self, target);
467 }
468
469 fn visit_assignment_target_property_identifier(
472 &mut self,
473 target: &AssignmentTargetPropertyIdentifier<'ast>,
474 ) {
475 if let Some(init) = &target.init {
476 self.infer_name_for_value(init, Some(target.binding.name.to_string()));
477 }
478 walk::walk_assignment_target_property_identifier(self, target);
479 }
480
481 fn visit_export_default_declaration(&mut self, decl: &ExportDefaultDeclaration<'ast>) {
484 let name = "default".to_owned();
485 match &decl.declaration {
486 ExportDefaultDeclarationKind::FunctionDeclaration(func) => {
487 self.inferred_names.insert(func.span.start, name);
488 }
489 kind => {
490 if let Some(value) = kind.as_expression() {
493 self.infer_name_for_value(value, Some(name));
494 }
495 }
496 }
497 walk::walk_export_default_declaration(self, decl);
498 }
499
500 fn visit_call_expression(&mut self, call: &CallExpression<'ast>) {
512 if !(call.optional && call.callee.get_member_expr().is_none()) {
513 self.name_callback_arguments(&call.callee, &call.arguments);
514 }
515 walk::walk_call_expression(self, call);
516 }
517
518 fn visit_new_expression(&mut self, new_expr: &NewExpression<'ast>) {
519 self.name_callback_arguments(&new_expr.callee, &new_expr.arguments);
520 walk::walk_new_expression(self, new_expr);
521 }
522}
523
524fn accessor_label(is_getter: bool, is_setter: bool, name: &str) -> String {
528 if is_getter {
529 return format!("get {name}");
530 }
531 if is_setter {
532 return format!("set {name}");
533 }
534 name.to_owned()
535}
536
537fn function_value_start(value: &Expression<'_>) -> Option<u32> {
543 match value.without_parentheses() {
544 Expression::FunctionExpression(func) => Some(func.span.start),
545 Expression::ArrowFunctionExpression(arrow) => Some(arrow.span.start),
546 _ => None,
547 }
548}
549
550fn assignment_target_name(target: &AssignmentTarget<'_>) -> Option<String> {
555 match target {
556 AssignmentTarget::AssignmentTargetIdentifier(ident) => Some(ident.name.to_string()),
557 AssignmentTarget::StaticMemberExpression(member) => Some(member.property.name.to_string()),
558 AssignmentTarget::ComputedMemberExpression(member) => match &member.expression {
559 Expression::StringLiteral(lit) => Some(lit.value.text().into_owned()),
560 _ => None,
561 },
562 _ => None,
563 }
564}
565
566fn callee_name(callee: &Expression<'_>) -> Option<String> {
572 match callee {
573 Expression::Identifier(ident) => Some(ident.name.to_string()),
574 Expression::StaticMemberExpression(member) => Some(member.property.name.to_string()),
575 Expression::ComputedMemberExpression(member) => match &member.expression {
576 Expression::StringLiteral(lit) => Some(lit.value.text().into_owned()),
577 _ => None,
578 },
579 Expression::ParenthesizedExpression(paren) => callee_name(&paren.expression),
583 _ => None,
584 }
585}
586
587#[derive(Debug, Clone, Copy, PartialEq, Eq)]
596pub struct InventoryComplexity {
597 pub cyclomatic: u16,
599 pub cognitive: u16,
601}
602
603#[must_use]
613pub fn walk_source(path: &Path, source: &str) -> Vec<InventoryEntry> {
614 walk_source_with_complexity(path, source).0
615}
616
617#[must_use]
629pub fn walk_source_with_complexity(
630 path: &Path,
631 source: &str,
632) -> (Vec<InventoryEntry>, FxHashMap<String, InventoryComplexity>) {
633 let source_type = SourceType::from_path(path).unwrap_or_default();
634 let line_offsets = fallow_types::extract::compute_line_offsets(source);
635
636 let primary = walk_one_parse(source, source_type, &line_offsets);
637 if primary.0.is_empty() && !source_type.is_jsx() {
638 let jsx_type = if source_type.is_typescript() {
639 SourceType::tsx()
640 } else {
641 SourceType::jsx()
642 };
643 let retry = walk_one_parse(source, jsx_type, &line_offsets);
644 if !retry.0.is_empty() {
645 return retry;
646 }
647 }
648
649 primary
650}
651
652fn walk_one_parse(
655 source: &str,
656 source_type: SourceType,
657 line_offsets: &[u32],
658) -> (Vec<InventoryEntry>, FxHashMap<String, InventoryComplexity>) {
659 crate::parse_bounded(source, || {
660 walk_one_parse_unbounded(source, source_type, line_offsets)
661 })
662 .unwrap_or_default()
663}
664
665fn walk_one_parse_unbounded(
666 source: &str,
667 source_type: SourceType,
668 line_offsets: &[u32],
669) -> (Vec<InventoryEntry>, FxHashMap<String, InventoryComplexity>) {
670 let allocator = Allocator::default();
671 let parser_return = Parser::new(&allocator, source, source_type).parse();
672
673 let mut visitor = InventoryVisitor::new(source, line_offsets);
674 visitor.visit_program(&parser_return.program);
675
676 let complexity =
677 crate::complexity::compute_complexity(&parser_return.program, source, line_offsets);
678 let metrics: FxHashMap<String, InventoryComplexity> = complexity
679 .into_iter()
680 .filter_map(|fc| {
681 fc.source_hash.map(|hash| {
682 (
683 hash,
684 InventoryComplexity {
685 cyclomatic: fc.cyclomatic,
686 cognitive: fc.cognitive,
687 },
688 )
689 })
690 })
691 .collect();
692
693 (visitor.entries, metrics)
694}
695
696#[cfg(all(test, not(miri)))]
697mod tests {
698 use super::*;
699 use std::path::PathBuf;
700
701 fn walk(source: &str) -> Vec<InventoryEntry> {
702 walk_source(&PathBuf::from("test.ts"), source)
703 }
704
705 #[test]
706 fn named_function_declaration_uses_its_own_name() {
707 let entries = walk("function foo() { return 1; }");
708 assert_eq!(entries.len(), 1);
709 assert_eq!(entries[0].name, "foo");
710 assert_eq!(entries[0].line, 1);
711 }
712
713 #[test]
714 fn const_arrow_captures_binding_name() {
715 let entries = walk("const bar = () => 42;");
716 assert_eq!(entries.len(), 1);
717 assert_eq!(entries[0].name, "bar");
718 }
719
720 #[test]
721 fn const_function_expression_keeps_its_own_name() {
722 let entries = walk("const outer = function inner() { return 1; };");
725 assert_eq!(entries.len(), 1);
726 assert_eq!(entries[0].name, "inner");
727 }
728
729 #[test]
730 fn object_property_function_keeps_its_own_name() {
731 let entries = walk(
732 r"
733 const o = {
734 k: function own() {},
735 j: function () {},
736 m() {},
737 get g() { return 1; },
738 };
739 ",
740 );
741 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
742 assert_eq!(names, vec!["own", "j", "m", "get g"]);
743 }
744
745 #[test]
746 fn own_name_beats_binding_and_does_not_leak_inward() {
747 let entries = walk("const f = function g() { return [1].map(() => 2); };");
750 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
751 assert_eq!(names, vec!["g", "map"]);
752 }
753
754 #[test]
755 fn parenthesized_declarator_and_property_values_take_the_binding_name() {
756 let entries = walk(
759 r"
760 const a = (() => 1);
761 const b = (function () {});
762 const c = (function own() {});
763 const o = { k: (() => 2) };
764 ",
765 );
766 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
767 assert_eq!(names, vec!["a", "b", "own", "k"]);
768 }
769
770 #[test]
771 fn declared_class_gives_no_name_to_its_members() {
772 let entries = walk(
776 r"
777 const C = class D { constructor() {} m() {} p = () => 1; };
778 const E = class { q = () => 2; };
779 ",
780 );
781 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
782 assert_eq!(
783 names,
784 vec!["constructor", "m", "(anonymous_2)", "(anonymous_3)"]
785 );
786 }
787
788 #[test]
789 fn class_methods_use_method_names() {
790 let entries = walk(
791 r"
792 class Foo {
793 bar() { return 1; }
794 baz() { return 2; }
795 }",
796 );
797 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
798 assert_eq!(names, vec!["bar", "baz"]);
799 }
800
801 #[test]
802 fn callback_argument_takes_the_callee_name() {
803 let entries = walk("setTimeout(() => { console.log('hi'); }, 10);");
806 assert_eq!(entries.len(), 1);
807 assert_eq!(entries[0].name, "setTimeout");
808 }
809
810 #[test]
811 fn member_callee_names_each_callback_in_source_order() {
812 let entries = walk(
813 r"
814 [1, 2, 3].map(() => 1);
815 [4, 5, 6].filter(() => true);
816 ",
817 );
818 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
819 assert_eq!(names, vec!["map", "filter"]);
820 }
821
822 #[test]
823 fn named_function_still_advances_counter_matching_instrumenter() {
824 let entries = walk(
828 r"
829 function named() { return 1; }
830 [1].map(() => 2);
831 ",
832 );
833 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
834 assert_eq!(names, vec!["named", "map"]);
835 }
836
837 #[test]
838 fn plain_identifier_callee_names_the_callback() {
839 let entries = walk("useMemo(() => compute());");
840 assert_eq!(entries[0].name, "useMemo");
841 }
842
843 #[test]
844 fn new_expression_callee_names_the_callback() {
845 let entries = walk("new Promise((resolve) => resolve(1));");
846 assert_eq!(entries[0].name, "Promise");
847 }
848
849 #[test]
850 fn callback_after_a_string_argument_is_named_from_the_callee() {
851 let entries = walk(r#"el.addEventListener("click", () => handle());"#);
854 assert_eq!(entries[0].name, "addEventListener");
855 }
856
857 #[test]
858 fn computed_string_key_callee_is_named() {
859 let entries = walk(r#"obj["handler"](() => run());"#);
860 assert_eq!(entries[0].name, "handler");
861 }
862
863 #[test]
864 fn chained_call_does_not_leak_the_earlier_callee_onto_the_later_callback() {
865 let entries = walk("p.then(() => a).catch(() => b);");
869 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
870 assert_eq!(names, vec!["then", "catch"]);
871 }
872
873 #[test]
874 fn nested_callbacks_each_take_their_own_callee() {
875 let entries = walk("outer(() => inner(() => 1));");
876 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
877 assert_eq!(names, vec!["outer", "inner"]);
878 }
879
880 #[test]
881 fn binding_name_wins_over_callee() {
882 let entries = walk("const handler = () => run();");
885 assert_eq!(entries[0].name, "handler");
886 }
887
888 #[test]
889 fn named_function_expression_argument_keeps_its_own_id() {
890 let entries = walk("run(function inner() { return 1; });");
891 assert_eq!(entries[0].name, "inner");
892 }
893
894 #[test]
895 fn iife_callee_stays_anonymous() {
896 let entries = walk("(function () { return 1; })();");
898 assert_eq!(entries[0].name, "(anonymous_0)");
899 }
900
901 #[test]
902 fn computed_non_string_callee_stays_anonymous() {
903 let entries = walk("handlers[index](() => run());");
904 assert_eq!(entries[0].name, "(anonymous_0)");
905 }
906
907 #[test]
908 fn parenthesized_callee_unwraps_to_the_inner_name() {
909 assert_eq!(walk("(foo)(() => run());")[0].name, "foo");
910 assert_eq!(walk("(a.b)(() => run());")[0].name, "b");
911 }
912
913 #[test]
914 fn optional_call_on_a_non_member_callee_gives_no_callee_name() {
915 assert_eq!(walk("foo?.(() => 1);")[0].name, "(anonymous_0)");
918 assert_eq!(walk("(foo)?.(() => 1);")[0].name, "(anonymous_0)");
919 assert_eq!(walk("(foo as any)?.(() => 1);")[0].name, "(anonymous_0)");
920 assert_eq!(walk("foo!?.(() => 1);")[0].name, "(anonymous_0)");
921 assert_eq!(walk("a?.b?.c?.(() => 1);")[0].name, "c");
922 }
923
924 #[test]
925 fn optional_call_on_a_member_callee_keeps_the_callee_name() {
926 assert_eq!(walk("a.b?.(() => 1);")[0].name, "b");
929 assert_eq!(walk("a?.b?.(() => 1);")[0].name, "b");
930 assert_eq!(walk("a['k']?.(() => 1);")[0].name, "k");
931 assert_eq!(walk("(a.b)?.(() => 1);")[0].name, "b");
932 assert_eq!(walk("a?.b(() => 1);")[0].name, "b");
933 assert_eq!(walk("a?.b?.c(() => 1);")[0].name, "c");
934 }
935
936 #[test]
937 fn optional_call_without_callee_name_still_names_a_nested_call_argument() {
938 let entries = walk("foo?.(() => 1, bar(() => 2));");
940 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
941 assert_eq!(names, vec!["(anonymous_0)", "bar"]);
942 }
943
944 #[test]
945 fn anonymous_after_named_chain_uses_next_counter_value() {
946 let entries = walk(
947 r"
948 function a() {}
949 function b() {}
950 function c() {}
951 const d = () => 4;
952 ",
953 );
954 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
955 assert_eq!(names, vec!["a", "b", "c", "d"]);
956 }
957
958 #[test]
959 fn typescript_overload_signatures_dont_emit_or_advance_counter() {
960 let entries = walk(
961 r"
962 function foo(): number;
963 function foo(s: string): string;
964 function foo(s?: string): number | string { return s ? s : 1; }
965 [1].map(() => 2);
966 ",
967 );
968 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
969 assert_eq!(names, vec!["foo", "map"]);
970 }
971
972 #[test]
973 fn export_default_named_function_keeps_explicit_name() {
974 let entries = walk("export default function foo() { return 1; }");
975 assert_eq!(entries.len(), 1);
976 assert_eq!(entries[0].name, "foo");
977 }
978
979 #[test]
980 fn export_default_anonymous_function_is_named_default() {
981 let entries = walk("export default function() { return 1; }");
982 assert_eq!(entries.len(), 1);
983 assert_eq!(entries[0].name, "default");
984 }
985
986 #[test]
987 fn export_default_anonymous_arrow_is_named_default() {
988 let entries = walk("export default () => 1;");
989 assert_eq!(entries.len(), 1);
990 assert_eq!(entries[0].name, "default");
991 }
992
993 #[test]
994 fn parenthesized_anonymous_default_export_is_named_default() {
995 assert_eq!(names("export default (() => 1);"), ["default"]);
996 assert_eq!(names("export default (function () {});"), ["default"]);
997 assert_eq!(
998 names("export default (function () { return () => 1; });"),
999 ["default", "(anonymous_1)"]
1000 );
1001 assert_eq!(names("export default (function own() {});"), ["own"]);
1002 }
1003
1004 #[test]
1005 fn nested_function_numbered_after_parent_in_traversal_order() {
1006 let entries = walk(
1007 r"
1008 function outer() {
1009 return function() { return 1; };
1010 }",
1011 );
1012 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
1013 assert_eq!(names, vec!["outer", "(anonymous_1)"]);
1014 }
1015
1016 #[test]
1017 fn line_number_is_one_based_from_source_start() {
1018 let entries = walk("\n\nfunction atLineThree() {}");
1019 assert_eq!(entries.len(), 1);
1020 assert_eq!(entries[0].line, 3);
1021 }
1022
1023 #[test]
1024 fn short_jsx_in_js_file_retries_with_jsx_parser() {
1025 let entries = walk_source(&PathBuf::from("component.js"), "const A = () => <div />;");
1026 assert_eq!(entries.len(), 1);
1027 assert_eq!(entries[0].name, "A");
1028 assert_eq!(entries[0].line, 1);
1029 }
1030
1031 #[test]
1032 fn object_method_shorthand_uses_the_key_name() {
1033 let entries = walk("const obj = { run() { return 1; } };");
1034 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
1035 assert_eq!(names, vec!["run"]);
1036 }
1037
1038 #[test]
1039 fn object_accessors_carry_the_get_and_set_label() {
1040 let entries = walk(
1041 r"
1042 const obj = {
1043 get closed() { return true; },
1044 set closed(value) { this.value = value; },
1045 };",
1046 );
1047 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
1048 assert_eq!(names, vec!["get closed", "set closed"]);
1049 }
1050
1051 #[test]
1052 fn function_valued_object_property_uses_the_key_name() {
1053 let entries = walk("const client = { execute: async (sql) => sql.length };");
1054 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
1055 assert_eq!(names, vec!["execute"]);
1056 }
1057
1058 #[test]
1059 fn object_property_holding_a_call_leaves_the_callback_to_its_callee() {
1060 let entries = walk("const column = { references: memo(() => other.id) };");
1063 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
1064 assert_eq!(names, vec!["memo"]);
1065 }
1066
1067 #[test]
1068 fn class_accessors_carry_the_get_and_set_label() {
1069 let entries = walk(
1070 r"
1071 class Client {
1072 get closed() { return true; }
1073 set closed(value) { this.value = value; }
1074 }",
1075 );
1076 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
1077 assert_eq!(names, vec!["get closed", "set closed"]);
1078 }
1079
1080 #[test]
1081 fn member_assignment_target_names_the_assigned_function() {
1082 let entries = walk(
1083 r#"
1084 client.execute = async (sql) => sql;
1085 client["rollback"] = function () { return 1; };
1086 "#,
1087 );
1088 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
1089 assert_eq!(names, vec!["execute", "rollback"]);
1090 }
1091
1092 #[test]
1093 fn identifier_assignment_target_names_the_assigned_function() {
1094 let entries = walk(
1097 r"
1098 let startLoad;
1099 startLoad = () => {};
1100 let handler;
1101 handler = function () { return 1; };
1102 ",
1103 );
1104 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
1105 assert_eq!(names, vec!["startLoad", "handler"]);
1106 }
1107
1108 #[test]
1109 fn parenthesized_assigned_function_takes_the_target_name() {
1110 let entries = walk(
1112 r"
1113 let x;
1114 x = (() => 1);
1115 o.m = (function () { return 2; });
1116 ",
1117 );
1118 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
1119 assert_eq!(names, vec!["x", "m"]);
1120 }
1121
1122 #[test]
1123 fn assigned_function_keeps_its_own_name() {
1124 let entries = walk(
1127 r"
1128 let n;
1129 n = function own() {};
1130 o.z = function inner() {};
1131 ",
1132 );
1133 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
1134 assert_eq!(names, vec!["own", "inner"]);
1135 }
1136
1137 #[test]
1138 fn assigned_class_gives_no_name_to_its_members() {
1139 let entries = walk(
1142 r"
1143 let X;
1144 X = class { p = () => 1; };
1145 o.Y = class { r = () => 2; };
1146 ",
1147 );
1148 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
1149 assert_eq!(names, vec!["(anonymous_0)", "(anonymous_1)"]);
1150 }
1151
1152 #[test]
1153 fn assignment_target_name_does_not_reach_the_left_side() {
1154 let entries = walk("f(() => 1).x = () => 2;");
1156 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
1157 assert_eq!(names, vec!["f", "x"]);
1158 }
1159
1160 #[test]
1161 fn compound_and_logical_assignments_give_no_name() {
1162 let entries = walk(
1165 r"
1166 let a;
1167 a ||= () => 1;
1168 let b;
1169 b &&= () => 2;
1170 let c;
1171 c ??= () => 3;
1172 let d = '';
1173 d += function () { return 4; };
1174 ",
1175 );
1176 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
1177 assert_eq!(
1178 names,
1179 vec![
1180 "(anonymous_0)",
1181 "(anonymous_1)",
1182 "(anonymous_2)",
1183 "(anonymous_3)"
1184 ]
1185 );
1186 }
1187
1188 #[test]
1189 fn only_callee_named_functions_are_flagged_as_callbacks() {
1190 let entries = walk(
1191 r"
1192 function declared() { return 1; }
1193 const bound = () => 2;
1194 const obj = { run() { return 3; } };
1195 [1].map(() => 4);
1196 (function () { return 5; })();
1197 ",
1198 );
1199 let flags: Vec<_> = entries
1200 .iter()
1201 .map(|e| (e.name.as_str(), e.is_callback))
1202 .collect();
1203 assert_eq!(
1204 flags,
1205 vec![
1206 ("declared", false),
1207 ("bound", false),
1208 ("run", false),
1209 ("map", true),
1210 ("(anonymous_4)", false),
1211 ]
1212 );
1213 }
1214
1215 #[test]
1216 fn drizzle_style_schema_names_every_callback_after_its_callee() {
1217 let entries = walk(
1221 r#"
1222 export const users = sqliteTable("users", {
1223 id: text("id").primaryKey(),
1224 orgId: text("org_id").references(() => orgs.id),
1225 }, (table) => [index("users_org_idx").on(table.orgId)]);
1226 "#,
1227 );
1228 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
1229 assert_eq!(names, vec!["references", "sqliteTable"]);
1230 assert!(entries.iter().all(|entry| entry.is_callback));
1231 }
1232
1233 fn names(source: &str) -> Vec<String> {
1234 walk_source(&PathBuf::from("test.tsx"), source)
1235 .into_iter()
1236 .map(|entry| entry.name)
1237 .collect()
1238 }
1239
1240 #[test]
1241 fn callee_name_does_not_reach_a_function_inside_a_named_argument() {
1242 assert_eq!(
1245 names("let x; foo(x = () => () => 2);"),
1246 ["x", "(anonymous_1)"]
1247 );
1248 assert_eq!(names("foo(o.x = () => () => 2);"), ["x", "(anonymous_1)"]);
1249 assert_eq!(
1250 names("foo({ k: (() => () => 1) });"),
1251 ["k", "(anonymous_1)"]
1252 );
1253 assert_eq!(
1254 names("foo({ k: function own() { return () => 1; } });"),
1255 ["own", "(anonymous_1)"]
1256 );
1257 assert_eq!(
1258 names("foo(function g() { return () => 1; });"),
1259 ["g", "(anonymous_1)"]
1260 );
1261 }
1262
1263 #[test]
1264 fn callee_name_applies_only_to_a_direct_argument() {
1265 assert_eq!(names("foo((() => 1));"), ["foo"]);
1268 assert_eq!(names("foo([() => 1]);"), ["(anonymous_0)"]);
1269 assert_eq!(names("foo(...[() => 1]);"), ["(anonymous_0)"]);
1270 assert_eq!(names("foo((() => 1) as any);"), ["(anonymous_0)"]);
1271 assert_eq!(names("foo(a ?? (() => 1));"), ["(anonymous_0)"]);
1272 assert_eq!(
1273 names("foo(c ? () => 1 : () => 2);"),
1274 ["(anonymous_0)", "(anonymous_1)"]
1275 );
1276 assert_eq!(names("render(<B onClick={() => 1} />);"), ["(anonymous_0)"]);
1277 assert_eq!(
1278 names("extendTailwindMerge({ extend: { classGroups: [() => 1] } });"),
1279 ["(anonymous_0)"]
1280 );
1281 assert_eq!(names("push({ k: a ?? (() => 1) });"), ["(anonymous_0)"]);
1282 }
1283
1284 #[test]
1285 fn function_default_value_takes_the_binding_name() {
1286 assert_eq!(names("function f(cb = () => 1) {}"), ["f", "cb"]);
1290 assert_eq!(names("function h(cb = (() => 1)) {}"), ["h", "cb"]);
1291 assert_eq!(names("function h(cb = function own() {}) {}"), ["h", "own"]);
1292 assert_eq!(names("const fn = (cb = () => 1) => cb;"), ["fn", "cb"]);
1293 assert_eq!(names("class P { m(cb = () => 1) {} }"), ["m", "cb"]);
1294 assert_eq!(
1295 names("function Button({ onClick = () => {} }) {}"),
1296 ["Button", "onClick"]
1297 );
1298 assert_eq!(names("function g({ k: v = () => 1 }) {}"), ["g", "v"]);
1299 assert_eq!(names("const { a = () => 1 } = o;"), ["a"]);
1300 assert_eq!(names("const { k: v = () => 1 } = o;"), ["v"]);
1301 assert_eq!(names("const [b = () => 1] = o;"), ["b"]);
1302 assert_eq!(names("[a = () => 1] = [];"), ["a"]);
1303 assert_eq!(names("({ a = () => 1 } = o);"), ["a"]);
1304 assert_eq!(names("({ k: v = () => 1 } = o);"), ["v"]);
1305 }
1306
1307 #[test]
1308 fn default_value_of_a_member_target_stays_anonymous() {
1309 assert_eq!(names("({ k: o.v = () => 1 } = x);"), ["(anonymous_0)"]);
1311 assert_eq!(names("[o.v = () => 1] = x;"), ["(anonymous_0)"]);
1312 }
1313
1314 #[test]
1315 fn class_property_arrow_uses_anonymous_counter() {
1316 let entries = walk(
1317 r"
1318 class Foo {
1319 bar = () => 1;
1320 }",
1321 );
1322 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
1323 assert_eq!(names, vec!["(anonymous_0)"]);
1324 }
1325
1326 #[test]
1327 fn records_one_indexed_utf16_columns() {
1328 let entries = walk("function foo() { return 1; }");
1329 assert_eq!(entries.len(), 1);
1330 assert_eq!(entries[0].start_column, 1);
1331 assert_eq!(entries[0].end_line, 1);
1332 assert!(entries[0].end_column > entries[0].start_column);
1333 }
1334
1335 #[test]
1336 fn utf16_column_counts_code_units_not_bytes() {
1337 let entries = walk("const e = \"\u{1F600}\"; const f = () => 1;");
1338 let f = entries.iter().find(|e| e.name == "f").expect("f present");
1339 let byte_prefix_len = "const e = \"\u{1F600}\"; const f = ".len() as u32;
1340 assert!(f.start_column < byte_prefix_len + 1);
1341 }
1342
1343 #[test]
1344 fn utf16_columns_stay_exact_across_a_long_single_line() {
1345 use std::fmt::Write as _;
1350 let mut src = String::new();
1351 for i in 0..40 {
1352 let _ = write!(src, "function f{i}() {{ return \"\u{1F600}\"; }} ");
1353 }
1354 src.push_str("function outer() { const inner = () => \"\u{1F600}\"; return inner; }");
1355 src.push_str("\nconst tail = () => 1;");
1356 let entries = walk(&src);
1357 let col = |byte: usize| src[..byte].encode_utf16().count() as u32 + 1;
1358
1359 for i in [0_usize, 17, 39] {
1360 let body = format!("function f{i}() {{ return \"\u{1F600}\"; }}");
1361 let start = src.find(&body).expect("function text present");
1362 let entry = entries
1363 .iter()
1364 .find(|e| e.name == format!("f{i}"))
1365 .expect("entry present");
1366 assert_eq!(entry.line, 1);
1367 assert_eq!(entry.start_column, col(start));
1368 assert_eq!(entry.end_line, 1);
1369 assert_eq!(entry.end_column, col(start + body.len()));
1370 }
1371
1372 let inner_start = src
1373 .find("() => \"\u{1F600}\"")
1374 .expect("inner arrow present");
1375 let inner = entries
1376 .iter()
1377 .find(|e| e.name == "inner")
1378 .expect("inner present");
1379 assert_eq!(inner.line, 1);
1380 assert_eq!(inner.start_column, col(inner_start));
1381
1382 let tail = entries
1383 .iter()
1384 .find(|e| e.name == "tail")
1385 .expect("tail present");
1386 let line2_start = src.find('\n').expect("newline present") + 1;
1387 let tail_start = src.rfind("() => 1").expect("tail arrow present");
1388 assert_eq!(tail.line, 2);
1389 assert_eq!(
1390 tail.start_column,
1391 src[line2_start..tail_start].encode_utf16().count() as u32 + 1
1392 );
1393 }
1394
1395 #[test]
1396 fn same_line_distinct_named_functions_have_distinct_positions() {
1397 let entries = walk("function a() {} function b() {}");
1398 let a = entries.iter().find(|e| e.name == "a").expect("a present");
1399 let b = entries.iter().find(|e| e.name == "b").expect("b present");
1400 assert_eq!(a.line, b.line, "both on line 1");
1401 assert_ne!(
1402 a.start_column, b.start_column,
1403 "same-line functions are column-disambiguated"
1404 );
1405 }
1406
1407 #[test]
1408 fn same_line_anonymous_functions_stay_distinct_via_counter() {
1409 let entries = walk("const xs = [() => 1, () => 2];");
1410 let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
1411 assert_eq!(names, vec!["(anonymous_0)", "(anonymous_1)"]);
1412 assert_eq!(entries[0].line, entries[1].line, "both on line 1");
1413 assert_ne!(
1414 entries[0].name, entries[1].name,
1415 "counter keeps them distinct"
1416 );
1417 }
1418
1419 fn nested_arrow_source(levels: usize) -> String {
1421 format!("export const f = {}1;\n", "()=>".repeat(levels))
1422 }
1423
1424 #[test]
1425 fn deep_nesting_keeps_the_hash_join_with_complexity() {
1426 let levels = crate::function_hash::MAX_HASHED_FUNCTION_HEIGHT as usize + 3;
1427 let source = nested_arrow_source(levels);
1428 let (entries, complexity) = walk_source_with_complexity(&PathBuf::from("a.js"), &source);
1429 assert_eq!(entries.len(), levels);
1430 for (index, entry) in entries.iter().enumerate() {
1433 let height = levels - 1 - index;
1434 let kept = height <= crate::function_hash::MAX_HASHED_FUNCTION_HEIGHT as usize;
1435 assert_eq!(entry.source_hash.is_some(), kept, "height {height}");
1436 if let Some(hash) = &entry.source_hash {
1437 assert!(
1438 complexity.contains_key(hash),
1439 "height {height} has no metrics"
1440 );
1441 }
1442 }
1443 }
1444
1445 #[test]
1446 fn column_lookups_stay_linear_on_nested_functions_in_one_line() {
1447 const STACK: usize = 64 << 20;
1450 let (encoded, entries, source_len) = std::thread::Builder::new()
1451 .stack_size(STACK)
1452 .spawn(|| {
1453 crate::register_thread_stack(STACK);
1454 take_utf16_bytes();
1455 let source = nested_arrow_source(4_000);
1456 let entries = walk_source(&PathBuf::from("a.js"), &source);
1457 (take_utf16_bytes(), entries.len(), source.len())
1458 })
1459 .expect("probe thread should start")
1460 .join()
1461 .expect("probe thread should finish");
1462 assert_eq!(entries, 4_000);
1463 assert!(
1464 encoded <= 4 * source_len,
1465 "encoded {encoded} bytes for {source_len}"
1466 );
1467 }
1468
1469 #[test]
1470 fn source_hash_is_the_content_digest_of_the_function_span() {
1471 let src = "function foo() { return 1; }";
1472 let entries = walk(src);
1473 assert_eq!(entries.len(), 1);
1474 let hash = entries[0]
1475 .source_hash
1476 .as_deref()
1477 .expect("a shallow function keeps its hash");
1478 assert_eq!(hash, fallow_cov_protocol::source_hash_for(src.as_bytes()));
1479 assert_eq!(hash.len(), 16);
1480 assert!(hash.chars().all(|c| c.is_ascii_hexdigit()));
1481 }
1482
1483 #[test]
1484 fn source_hash_survives_line_moves_and_tracks_body_edits() {
1485 let original = walk("function foo() { return 1; }");
1486 let moved = walk("\n\nfunction foo() { return 1; }");
1487 assert_eq!(
1488 original[0].source_hash, moved[0].source_hash,
1489 "a moved-but-unedited function must keep its source_hash"
1490 );
1491 let edited = walk("function foo() { return 2; }");
1492 assert_ne!(
1493 original[0].source_hash, edited[0].source_hash,
1494 "an edited body must change the source_hash"
1495 );
1496 }
1497}