use oxc_ast::ast::{
Argument, ArrayExpressionElement, ArrowFunctionBody, BinaryExpression, BindingPattern,
CallExpression, Class, ClassElement, Expression, MethodDefinitionKind, ObjectPropertyKind,
PropertyDefinition, PropertyKey, Statement, TSAccessibility, TSSignature, TSType,
TSTypeAnnotation, TSTypeName, TSTypeParameterInstantiation,
};
use oxc_span::{GetSpan, Span};
use rustc_hash::{FxHashMap, FxHashSet};
#[path = "helpers_heritage_names.rs"]
pub(in crate::visitor) mod heritage_names;
#[path = "helpers_heritage_root.rs"]
mod heritage_root;
#[path = "helpers_host_refs.rs"]
mod host_refs;
#[path = "helpers_return_bindings.rs"]
mod return_bindings;
pub(super) use super::visit_impl::visit_value_alias::is_builtin_constructor;
use super::visit_impl::visit_value_alias::value_alias_source;
use crate::js_text::JsText;
use crate::{MemberInfo, MemberKind};
use fallow_types::extract::{AngularInputMember, AngularOutputMember};
use heritage_names::{extract_static_expression_name, extract_type_name};
use heritage_root::heritage_root_name;
pub(super) use heritage_root::is_object_literal_initializer;
use host_refs::extract_host_member_refs;
#[cfg(test)]
use host_refs::{extract_identifiers_from_host_expr, is_valid_member_identifier};
use return_bindings::{
collect_getter_binding, collect_method_return_binding, is_self_returning_instance_method,
push_array_element_binding, returns_named_class_type,
};
pub struct AngularComponentMetadata {
pub template_url: Option<String>,
pub style_urls: Vec<String>,
pub inline_template: Option<String>,
pub inline_template_offset: Option<u32>,
pub decorator_span: Span,
pub host_member_refs: Vec<String>,
pub input_output_members: Vec<String>,
pub selector: Option<String>,
}
const ANGULAR_SIGNAL_APIS: &[&str] = &[
"input",
"output",
"outputFromObservable",
"model",
"viewChild",
"viewChildren",
"contentChild",
"contentChildren",
];
pub fn extract_angular_component_metadata(class: &Class<'_>) -> Option<AngularComponentMetadata> {
for decorator in &class.decorators {
if let Some(metadata) = extract_decorator_metadata(decorator) {
return Some(metadata);
}
}
None
}
#[derive(Default)]
struct AngularMetadataAccumulator {
template_url: Option<String>,
style_urls: Vec<String>,
inline_template: Option<String>,
inline_template_offset: Option<u32>,
host_member_refs: Vec<String>,
input_output_members: Vec<String>,
selector: Option<String>,
}
impl AngularMetadataAccumulator {
fn has_data(&self) -> bool {
self.template_url.is_some()
|| !self.style_urls.is_empty()
|| self.inline_template.is_some()
|| !self.host_member_refs.is_empty()
|| !self.input_output_members.is_empty()
|| self.selector.is_some()
}
fn into_metadata(self, decorator_span: Span) -> AngularComponentMetadata {
AngularComponentMetadata {
template_url: self.template_url,
style_urls: self.style_urls,
inline_template: self.inline_template,
inline_template_offset: self.inline_template_offset,
decorator_span,
host_member_refs: self.host_member_refs,
input_output_members: self.input_output_members,
selector: self.selector,
}
}
}
fn extract_decorator_metadata(
decorator: &oxc_ast::ast::Decorator<'_>,
) -> Option<AngularComponentMetadata> {
let Expression::CallExpression(call) = &decorator.expression else {
return None;
};
let Expression::Identifier(id) = &call.callee else {
return None;
};
if !matches!(id.name.as_str(), "Component" | "Directive") {
return None;
}
let is_component = id.name.as_str() == "Component";
let Some(Argument::ObjectExpression(obj)) = call.arguments.first() else {
return None;
};
let mut acc = AngularMetadataAccumulator::default();
for prop in &obj.properties {
let ObjectPropertyKind::ObjectProperty(p) = prop else {
continue;
};
let Some(key_name) = p.key.static_name() else {
continue;
};
apply_decorator_property(&mut acc, &key_name.text(), p, is_component);
}
acc.has_data().then(|| acc.into_metadata(decorator.span()))
}
fn apply_decorator_property(
acc: &mut AngularMetadataAccumulator,
key_name: &str,
p: &oxc_ast::ast::ObjectProperty<'_>,
is_component: bool,
) {
match key_name {
"selector" if is_component => {
if let Expression::StringLiteral(lit) = &p.value {
acc.selector = Some(lit.value.text().into_owned());
}
}
"templateUrl" => {
if let Expression::StringLiteral(lit) = &p.value {
acc.template_url = Some(lit.value.text().into_owned());
}
}
"template" => apply_inline_template(acc, p),
"styleUrl" => {
if let Expression::StringLiteral(lit) = &p.value {
acc.style_urls.push(lit.value.text().into_owned());
}
}
"styleUrls" => {
if let Expression::ArrayExpression(arr) = &p.value {
for elem in &arr.elements {
if let ArrayExpressionElement::StringLiteral(lit) = elem {
acc.style_urls.push(lit.value.text().into_owned());
}
}
}
}
"host" => {
if let Expression::ObjectExpression(host_obj) = &p.value {
extract_host_member_refs(host_obj, &mut acc.host_member_refs);
}
}
"inputs" | "outputs" => {
extract_input_output_members(&p.value, &mut acc.input_output_members);
}
"queries" => {
extract_query_members(&p.value, &mut acc.input_output_members);
}
_ => {}
}
}
fn apply_inline_template(
acc: &mut AngularMetadataAccumulator,
p: &oxc_ast::ast::ObjectProperty<'_>,
) {
if let Expression::StringLiteral(lit) = &p.value {
acc.inline_template = Some(lit.value.text().into_owned());
acc.inline_template_offset = Some(lit.span.start.saturating_add(1));
} else if let Expression::TemplateLiteral(tpl) = &p.value
&& tpl.expressions.is_empty()
&& let Some(quasi) = tpl.quasis.first()
{
let source = quasi
.value
.cooked
.map_or_else(|| quasi.value.raw.as_str().into(), JsText::text)
.into_owned();
acc.inline_template = Some(source);
acc.inline_template_offset = Some(p.value.span().start.saturating_add(1));
}
}
fn extract_query_members(value: &Expression<'_>, members: &mut Vec<String>) {
let Expression::ObjectExpression(obj) = value else {
return;
};
for prop in &obj.properties {
let ObjectPropertyKind::ObjectProperty(p) = prop else {
continue;
};
if let Some(name) = p.key.static_name() {
let name = name.text().into_owned();
if !name.is_empty() {
members.push(name);
}
}
}
}
fn extract_input_output_members(value: &Expression<'_>, members: &mut Vec<String>) {
let Expression::ArrayExpression(arr) = value else {
return;
};
for elem in &arr.elements {
let ArrayExpressionElement::StringLiteral(lit) = elem else {
continue;
};
let text = lit.value.text();
let member = text.split(':').next().unwrap_or_default().trim();
if !member.is_empty() {
members.push(member.to_string());
}
}
}
pub fn has_angular_class_decorator(class: &Class<'_>) -> bool {
class.decorators.iter().any(|d| {
if let Expression::CallExpression(call) = &d.expression
&& let Expression::Identifier(id) = &call.callee
{
matches!(
id.name.as_str(),
"Component" | "Directive" | "Injectable" | "Pipe"
)
} else {
false
}
})
}
#[derive(Debug, Clone)]
pub(super) enum LitCustomElementDecorator {
Named { local_name: String },
Namespace { local_name: String },
}
pub(super) fn lit_custom_element_decorator(class: &Class<'_>) -> Option<LitCustomElementDecorator> {
class.decorators.iter().find_map(|d| {
let Expression::CallExpression(call) = &d.expression else {
return None;
};
match &call.callee {
Expression::Identifier(id) => Some(LitCustomElementDecorator::Named {
local_name: id.name.to_string(),
}),
Expression::StaticMemberExpression(member)
if member.property.name == "customElement" =>
{
let Expression::Identifier(object) = &member.object else {
return None;
};
Some(LitCustomElementDecorator::Namespace {
local_name: object.name.to_string(),
})
}
_ => None,
}
})
}
pub(super) fn lit_custom_element_tag(class: &Class<'_>) -> Option<String> {
class.decorators.iter().find_map(|d| {
let Expression::CallExpression(call) = &d.expression else {
return None;
};
let is_custom_element = match &call.callee {
Expression::Identifier(id) => id.name == "customElement",
Expression::StaticMemberExpression(member) => member.property.name == "customElement",
_ => false,
};
if !is_custom_element {
return None;
}
match call.arguments.first()? {
Argument::StringLiteral(lit) => Some(lit.value.text().into_owned()),
_ => None,
}
})
}
pub fn extract_custom_elements_define(
call: &oxc_ast::ast::CallExpression<'_>,
) -> Option<(String, String)> {
let Expression::StaticMemberExpression(member) = &call.callee else {
return None;
};
if member.property.name != "define" || !is_custom_elements_receiver(&member.object) {
return None;
}
let tag = match call.arguments.first()? {
Argument::StringLiteral(lit) => lit.value.text().into_owned(),
_ => return None,
};
let class_name = match call.arguments.get(1)? {
Argument::Identifier(id) => id.name.to_string(),
_ => return None,
};
Some((tag, class_name))
}
pub(super) fn extract_custom_element_tag_reference(
call: &oxc_ast::ast::CallExpression<'_>,
) -> Option<String> {
let Expression::StaticMemberExpression(member) = &call.callee else {
return None;
};
let recognized = match member.property.name.as_str() {
"createElement" => true,
"get" | "whenDefined" => is_custom_elements_receiver(&member.object),
_ => return None,
};
if !recognized {
return None;
}
let Argument::StringLiteral(lit) = call.arguments.first()? else {
return None;
};
let tag = &*lit.value.text();
tag.contains('-').then(|| tag.to_string())
}
fn is_custom_elements_receiver(expr: &Expression<'_>) -> bool {
match expr {
Expression::Identifier(id) => id.name == "customElements",
Expression::StaticMemberExpression(member) => member.property.name == "customElements",
_ => false,
}
}
fn is_angular_signal_initializer(value: &Expression<'_>) -> bool {
angular_signal_initializer_name(value).is_some()
}
fn angular_signal_initializer_name<'a>(value: &'a Expression<'a>) -> Option<&'a str> {
let Expression::CallExpression(call) = value else {
return None;
};
match &call.callee {
Expression::Identifier(id) => {
let name = id.name.as_str();
ANGULAR_SIGNAL_APIS.contains(&name).then_some(name)
}
Expression::StaticMemberExpression(member) => {
if let Expression::Identifier(obj) = &member.object {
let name = obj.name.as_str();
(ANGULAR_SIGNAL_APIS.contains(&name) && member.property.name == "required")
.then_some(name)
} else {
None
}
}
_ => None,
}
}
pub(super) struct AngularSignalQuery {
pub type_arg: String,
pub plural: bool,
}
pub(super) fn extract_angular_signal_query(value: &Expression<'_>) -> Option<AngularSignalQuery> {
let Expression::CallExpression(call) = value else {
return None;
};
let Expression::Identifier(id) = &call.callee else {
return None;
};
let plural = match id.name.as_str() {
"viewChild" | "contentChild" => false,
"viewChildren" | "contentChildren" => true,
_ => return None,
};
if let Some(type_args) = call.type_arguments.as_deref()
&& let Some(first) = type_args.params.first()
&& let Some(name) = extract_type_reference_name(first)
&& !is_builtin_constructor(&name)
{
return Some(AngularSignalQuery {
type_arg: name,
plural,
});
}
if let Some(Argument::Identifier(arg_id)) = call.arguments.first()
&& !is_builtin_constructor(arg_id.name.as_str())
{
return Some(AngularSignalQuery {
type_arg: arg_id.name.to_string(),
plural,
});
}
None
}
pub(super) fn extract_query_list_element_type(annotation: &TSTypeAnnotation<'_>) -> Option<String> {
extract_query_list_from_type(&annotation.type_annotation)
}
fn extract_query_list_from_type(ty: &TSType<'_>) -> Option<String> {
match ty {
TSType::TSTypeReference(type_ref) => {
let name = extract_type_name(&type_ref.type_name)?;
if name != "QueryList" {
return None;
}
let type_args = type_ref.type_arguments.as_deref()?;
let first = type_args.params.first()?;
let element = extract_type_reference_name(first)?;
if is_builtin_constructor(&element) {
None
} else {
Some(element)
}
}
TSType::TSParenthesizedType(paren) => extract_query_list_from_type(&paren.type_annotation),
TSType::TSUnionType(union) => {
let mut found: Option<String> = None;
for branch in &union.types {
match branch {
TSType::TSNullKeyword(_) | TSType::TSUndefinedKeyword(_) => {}
other => {
if found.is_some() {
return None;
}
found = extract_query_list_from_type(other);
found.as_ref()?;
}
}
}
found
}
_ => None,
}
}
const VUE_REACTIVITY_WRAPPERS: &[&str] = &[
"ref",
"computed",
"shallowRef",
"reactive",
"shallowReactive",
"readonly",
"toRef",
"customRef",
];
pub(super) fn array_element_type_from_type(ty: &TSType<'_>) -> Option<String> {
array_element_target_from_type(ty).map(|(name, _)| name)
}
pub(super) fn array_element_target_from_type(ty: &TSType<'_>) -> Option<(String, Option<Span>)> {
match ty {
TSType::TSArrayType(arr) => {
let name = extract_type_reference_name(&arr.element_type)?;
(!is_builtin_constructor(&name))
.then(|| (name, extract_type_reference_origin(&arr.element_type)))
}
TSType::TSTypeReference(type_ref) => {
let name = extract_type_name(&type_ref.type_name)?;
if name != "Array" && name != "ReadonlyArray" {
return None;
}
let first = type_ref.type_arguments.as_deref()?.params.first()?;
let element = extract_type_reference_name(first)?;
(!is_builtin_constructor(&element))
.then(|| (element, extract_type_reference_origin(first)))
}
TSType::TSTypeOperatorType(op)
if op.operator == oxc_ast::ast::TSTypeOperatorOperator::Readonly =>
{
array_element_target_from_type(&op.type_annotation)
}
TSType::TSParenthesizedType(paren) => {
array_element_target_from_type(&paren.type_annotation)
}
TSType::TSUnionType(union) => {
let mut found: Option<(String, Option<Span>)> = None;
for branch in &union.types {
match branch {
TSType::TSNullKeyword(_) | TSType::TSUndefinedKeyword(_) => {}
other => {
if found.is_some() {
return None;
}
found = array_element_target_from_type(other);
found.as_ref()?;
}
}
}
found
}
_ => None,
}
}
pub(super) fn map_value_type_from_type(ty: &TSType<'_>) -> Option<String> {
match ty {
TSType::TSTypeReference(type_ref) => {
let name = extract_type_name(&type_ref.type_name)?;
if name != "Map" && name != "ReadonlyMap" {
return None;
}
map_value_type_from_args(type_ref.type_arguments.as_deref())
}
TSType::TSParenthesizedType(paren) => map_value_type_from_type(&paren.type_annotation),
TSType::TSUnionType(union) => {
let mut found: Option<String> = None;
for branch in &union.types {
match branch {
TSType::TSNullKeyword(_) | TSType::TSUndefinedKeyword(_) => {}
other => {
if found.is_some() {
return None;
}
found = map_value_type_from_type(other);
found.as_ref()?;
}
}
}
found
}
_ => None,
}
}
pub(super) fn map_value_type_from_new(expr: &Expression<'_>) -> Option<String> {
match expr {
Expression::ParenthesizedExpression(paren) => map_value_type_from_new(&paren.expression),
Expression::NewExpression(new_expr) => {
let Expression::Identifier(callee) = &new_expr.callee else {
return None;
};
if callee.name != "Map" {
return None;
}
map_value_type_from_args(new_expr.type_arguments.as_deref())
}
_ => None,
}
}
fn map_value_type_from_args(args: Option<&TSTypeParameterInstantiation<'_>>) -> Option<String> {
let args = args?;
if args.params.len() != 2 {
return None;
}
let value = extract_type_reference_name(&args.params[1])?;
(!is_builtin_constructor(&value)).then_some(value)
}
fn infer_array_binding_element_type(
type_annotation: Option<&TSTypeAnnotation<'_>>,
init: Option<&Expression<'_>>,
) -> Option<String> {
infer_array_binding_element_target(type_annotation, init).map(|(name, _)| name)
}
pub(super) fn infer_array_binding_element_target(
type_annotation: Option<&TSTypeAnnotation<'_>>,
init: Option<&Expression<'_>>,
) -> Option<(String, Option<Span>)> {
if let Some(annotation) = type_annotation {
return array_element_target_from_type(&annotation.type_annotation);
}
infer_array_element_from_init(init?)
}
fn infer_array_element_from_init(expr: &Expression<'_>) -> Option<(String, Option<Span>)> {
match expr {
Expression::ParenthesizedExpression(paren) => {
infer_array_element_from_init(&paren.expression)
}
Expression::AwaitExpression(await_expr) => {
infer_array_element_from_init(&await_expr.argument)
}
Expression::ArrayExpression(arr) => array_literal_element_type(arr),
Expression::CallExpression(call) => reactivity_wrapper_element_type(call),
_ => None,
}
}
pub(super) fn return_type_element_name(ty: &TSType<'_>) -> Option<String> {
return_type_element_target(ty).map(|(name, _)| name)
}
pub(super) fn return_type_element_target(ty: &TSType<'_>) -> Option<(String, Option<Span>)> {
match ty {
TSType::TSParenthesizedType(paren) => return_type_element_target(&paren.type_annotation),
TSType::TSTypeReference(type_ref) => {
let name = extract_type_name(&type_ref.type_name)?;
if name == "Promise" {
let first = type_ref.type_arguments.as_deref()?.params.first()?;
return extract_type_reference_name(first)
.filter(|inner| !is_builtin_constructor(inner))
.map(|inner| (inner, extract_type_reference_origin(first)));
}
(!is_builtin_constructor(&name)).then(|| (name, extract_type_reference_origin(ty)))
}
_ => None,
}
}
fn reactivity_wrapper_element_type(call: &CallExpression<'_>) -> Option<(String, Option<Span>)> {
let Expression::Identifier(callee) = &call.callee else {
return None;
};
if !VUE_REACTIVITY_WRAPPERS.contains(&callee.name.as_str()) {
return None;
}
if let Some(type_args) = call.type_arguments.as_deref()
&& let Some(first) = type_args.params.first()
&& let Some(element) = array_element_target_from_type(first)
{
return Some(element);
}
callback_returned_array_element(call.arguments.first()?)
}
pub(super) fn callback_returned_array_element(
arg: &Argument<'_>,
) -> Option<(String, Option<Span>)> {
match arg {
Argument::ArrowFunctionExpression(arrow) => match &arrow.body {
ArrowFunctionBody::FunctionBody(body) => function_body_returned_array_element(body),
body => array_literal_element_type_of_expr(body.as_expression()?),
},
Argument::FunctionExpression(func) => {
function_body_returned_array_element(func.body.as_deref()?)
}
_ => None,
}
}
fn function_body_returned_array_element(
body: &oxc_ast::ast::FunctionBody<'_>,
) -> Option<(String, Option<Span>)> {
let Statement::ReturnStatement(ret) = body.statements.last()? else {
return None;
};
match unwrap_returned_expr(ret.argument.as_ref()?) {
Expression::ArrayExpression(arr) => array_literal_element_type(arr),
Expression::Identifier(id) => local_typed_array_element(&body.statements, &id.name),
_ => None,
}
}
fn unwrap_returned_expr<'a, 'b>(expr: &'b Expression<'a>) -> &'b Expression<'a> {
match expr {
Expression::ParenthesizedExpression(paren) => unwrap_returned_expr(&paren.expression),
other => other,
}
}
fn array_literal_element_type_of_expr(expr: &Expression<'_>) -> Option<(String, Option<Span>)> {
match expr {
Expression::ParenthesizedExpression(paren) => {
array_literal_element_type_of_expr(&paren.expression)
}
Expression::ArrayExpression(arr) => array_literal_element_type(arr),
_ => None,
}
}
fn array_literal_element_type(
arr: &oxc_ast::ast::ArrayExpression<'_>,
) -> Option<(String, Option<Span>)> {
let mut element: Option<(String, Option<Span>)> = None;
for item in &arr.elements {
let ArrayExpressionElement::NewExpression(new_expr) = item else {
return None;
};
let Expression::Identifier(callee) = &new_expr.callee else {
return None;
};
let name = callee.name.as_str();
if is_builtin_constructor(name) {
return None;
}
match &element {
Some((existing, _)) if existing != name => return None,
Some(_) => {}
None => element = Some((name.to_string(), Some(callee.span))),
}
}
element
}
fn local_typed_array_element(
statements: &[Statement<'_>],
name: &str,
) -> Option<(String, Option<Span>)> {
for stmt in statements {
let Statement::VariableDeclaration(decl) = stmt else {
continue;
};
for declarator in &decl.declarations {
let BindingPattern::BindingIdentifier(id) = &declarator.id else {
continue;
};
if id.name != name {
continue;
}
if let Some(annotation) = declarator.type_annotation.as_deref() {
return array_element_target_from_type(&annotation.type_annotation);
}
}
}
None
}
pub(super) fn collect_component_field_array_types(class: &Class<'_>) -> FxHashMap<String, String> {
let mut field_types: FxHashMap<String, String> = FxHashMap::default();
for element in &class.body.body {
let ClassElement::PropertyDefinition(prop) = element else {
continue;
};
if matches!(prop.accessibility, Some(TSAccessibility::Private)) {
continue;
}
let Some(name) = prop.key.static_name() else {
continue;
};
if let Some(element_type) =
infer_array_binding_element_type(prop.type_annotation.as_deref(), prop.value.as_ref())
{
field_types.insert(name.text().into_owned(), element_type);
}
}
field_types
}
pub(super) fn has_angular_plural_query_decorator(
decorators: &[oxc_ast::ast::Decorator<'_>],
) -> bool {
decorators.iter().any(|decorator| {
let Expression::CallExpression(call) = &decorator.expression else {
return false;
};
let Expression::Identifier(id) = &call.callee else {
return false;
};
matches!(id.name.as_str(), "ViewChildren" | "ContentChildren")
})
}
pub fn extract_class_members(
class: &Class<'_>,
is_angular_class: bool,
plain_object_names: Option<&FxHashSet<String>>,
) -> Vec<MemberInfo> {
let class_name = class.id.as_ref().map(|id| id.name.as_str());
let heritage_root = class
.heritage
.as_ref()
.and_then(|heritage| heritage_root_name(&heritage.expression, plain_object_names));
let override_base = |is_override: bool| heritage_root.clone().filter(|_| is_override);
let mut members = Vec::new();
let mut overload_slots: FxHashSet<(bool, String)> = FxHashSet::default();
for element in &class.body.body {
match element {
ClassElement::MethodDefinition(method) => {
if !is_member_slot_of_method(class, method, &mut overload_slots) {
continue;
}
if let Some(mut member) = build_method_member(method, class_name) {
member.override_base = override_base(method.r#override);
merge_overload_return_flags(class, method, class_name, &mut member);
members.push(member);
}
}
ClassElement::PropertyDefinition(prop) => {
if let Some(mut member) = build_property_member(prop, is_angular_class) {
member.override_base = override_base(prop.r#override);
members.push(member);
}
}
_ => {}
}
}
members
}
fn is_member_slot_of_method(
class: &Class<'_>,
method: &oxc_ast::ast::MethodDefinition<'_>,
overload_slots: &mut FxHashSet<(bool, String)>,
) -> bool {
if method.kind != MethodDefinitionKind::Method {
return true;
}
let Some(name) = method.key.static_name() else {
return true;
};
if method.value.body.is_some() {
return true;
}
let has_implementation = class.body.body.iter().any(|element| {
matches!(
element,
ClassElement::MethodDefinition(other)
if other.kind == MethodDefinitionKind::Method
&& other.r#static == method.r#static
&& other.value.body.is_some()
&& other.key.static_name().is_some_and(|other_name| other_name == name)
)
});
!has_implementation && overload_slots.insert((method.r#static, name.text().into_owned()))
}
fn merge_overload_return_flags(
class: &Class<'_>,
method: &oxc_ast::ast::MethodDefinition<'_>,
class_name: Option<&str>,
member: &mut MemberInfo,
) {
if method.kind != MethodDefinitionKind::Method {
return;
}
let Some(name) = method.key.static_name() else {
return;
};
for element in &class.body.body {
let ClassElement::MethodDefinition(other) = element else {
continue;
};
if std::ptr::eq(other.as_ref(), method)
|| other.kind != MethodDefinitionKind::Method
|| other.r#static != method.r#static
|| other
.key
.static_name()
.is_none_or(|other_name| other_name != name)
{
continue;
}
if method.r#static {
member.is_instance_returning_static |=
is_instance_returning_static_method(other, class_name);
} else {
member.is_self_returning |= is_self_returning_instance_method(other, class_name);
}
}
}
fn build_method_member(
method: &oxc_ast::ast::MethodDefinition<'_>,
class_name: Option<&str>,
) -> Option<MemberInfo> {
let name_str = method.key.static_name()?.text().into_owned();
if name_str == "constructor"
|| matches!(method.key, PropertyKey::PrivateIdentifier(_))
|| matches!(method.accessibility, Some(TSAccessibility::Private))
{
return None;
}
let is_instance_returning_static =
method.r#static && is_instance_returning_static_method(method, class_name);
let is_self_returning =
!method.r#static && is_self_returning_instance_method(method, class_name);
let decorator_names = method
.decorators
.iter()
.map(|d| decorator_path(&d.expression))
.collect();
Some(MemberInfo {
name: name_str,
kind: MemberKind::ClassMethod,
span: method.span,
has_decorator: !method.decorators.is_empty(),
decorator_names,
is_instance_returning_static,
is_self_returning,
override_base: None,
is_protected: matches!(method.accessibility, Some(TSAccessibility::Protected)),
is_static: method.r#static,
})
}
fn build_property_member(
prop: &oxc_ast::ast::PropertyDefinition<'_>,
is_angular_class: bool,
) -> Option<MemberInfo> {
let name = prop.key.static_name()?;
if prop.declare
|| matches!(prop.key, PropertyKey::PrivateIdentifier(_))
|| matches!(prop.accessibility, Some(TSAccessibility::Private))
{
return None;
}
let has_decorator = !prop.decorators.is_empty()
|| (is_angular_class
&& prop
.value
.as_ref()
.is_some_and(is_angular_signal_initializer));
let decorator_names = prop
.decorators
.iter()
.map(|d| decorator_path(&d.expression))
.collect();
Some(MemberInfo {
name: name.text().into_owned(),
kind: MemberKind::ClassProperty,
span: prop.span,
has_decorator,
decorator_names,
is_instance_returning_static: false,
is_self_returning: false,
override_base: None,
is_protected: matches!(prop.accessibility, Some(TSAccessibility::Protected)),
is_static: prop.r#static,
})
}
pub fn extract_angular_inputs_outputs(
class: &Class<'_>,
) -> (Vec<AngularInputMember>, Vec<AngularOutputMember>) {
let mut inputs = Vec::new();
let mut outputs = Vec::new();
for element in &class.body.body {
let ClassElement::PropertyDefinition(prop) = element else {
continue;
};
let Some(name) = prop.key.static_name() else {
continue;
};
let span_start = prop.key.span().start;
if let Some(role) = angular_decorator_member_role(prop) {
match role {
AngularMemberRole::Input => inputs.push(AngularInputMember {
name: name.text().into_owned(),
span_start,
}),
AngularMemberRole::Output => {
if output_is_event_emitter(prop.value.as_ref()) {
outputs.push(AngularOutputMember {
name: name.text().into_owned(),
span_start,
});
}
}
}
continue;
}
if let Some(signal_name) = prop
.value
.as_ref()
.and_then(|value| angular_signal_initializer_name(value))
{
match signal_name {
"input" | "model" => inputs.push(AngularInputMember {
name: name.text().into_owned(),
span_start,
}),
"output" | "outputFromObservable" => outputs.push(AngularOutputMember {
name: name.text().into_owned(),
span_start,
}),
_ => {}
}
}
}
(inputs, outputs)
}
fn angular_decorator_member_role(prop: &PropertyDefinition<'_>) -> Option<AngularMemberRole> {
prop.decorators.iter().find_map(|decorator| {
match decorator_path(&decorator.expression).as_str() {
"Input" => Some(AngularMemberRole::Input),
"Output" => Some(AngularMemberRole::Output),
_ => None,
}
})
}
enum AngularMemberRole {
Input,
Output,
}
fn output_is_event_emitter(value: Option<&Expression<'_>>) -> bool {
let Some(Expression::NewExpression(new_expr)) = value else {
return false;
};
match &new_expr.callee {
Expression::Identifier(ident) => ident.name.as_str() == "EventEmitter",
Expression::StaticMemberExpression(member) => {
member.property.name.as_str() == "EventEmitter"
}
_ => false,
}
}
fn is_instance_returning_static_method(
method: &oxc_ast::ast::MethodDefinition<'_>,
class_name: Option<&str>,
) -> bool {
if returns_named_class_type(method.value.return_type.as_ref(), class_name) {
return true;
}
if method.value.r#async
&& let (Some(name), Some(annotation)) = (class_name, method.value.return_type.as_deref())
&& return_type_element_name(&annotation.type_annotation).is_some_and(|ty| ty == name)
{
return true;
}
let Some(body) = method.value.body.as_ref() else {
return false;
};
body.statements
.last()
.is_some_and(|stmt| statement_returns_class_instance(stmt, class_name))
}
fn statement_returns_class_instance(stmt: &Statement<'_>, class_name: Option<&str>) -> bool {
let Statement::ReturnStatement(ret) = stmt else {
return false;
};
let Some(expr) = ret.argument.as_ref() else {
return false;
};
is_self_construction_expression(expr, class_name)
}
fn is_self_construction_expression(expr: &Expression<'_>, class_name: Option<&str>) -> bool {
let Expression::NewExpression(new_expr) = expr else {
return false;
};
match &new_expr.callee {
Expression::ThisExpression(_) => true,
Expression::Identifier(ident) => class_name.is_some_and(|name| ident.name.as_str() == name),
_ => false,
}
}
pub fn extract_super_class_name(class: &Class<'_>) -> Option<String> {
extract_static_expression_name(&class.heritage.as_ref()?.expression)
}
#[must_use]
pub fn extract_implemented_interface_names(class: &Class<'_>) -> Vec<String> {
class
.implements
.iter()
.filter_map(|item| extract_type_name(&item.expression))
.collect()
}
#[must_use]
pub fn extract_type_annotation_name(type_annotation: &TSTypeAnnotation<'_>) -> Option<String> {
extract_type_reference_name(&type_annotation.type_annotation)
}
pub(super) fn extract_nested_type_bindings(
type_annotation: &TSTypeAnnotation<'_>,
) -> Vec<(String, String, Option<Span>)> {
let mut bindings = Vec::new();
collect_nested_type_bindings(&type_annotation.type_annotation, None, &mut bindings);
bindings
}
pub(super) fn collect_nested_type_bindings(
ty: &TSType<'_>,
prefix: Option<&str>,
bindings: &mut Vec<(String, String, Option<Span>)>,
) {
match ty {
TSType::TSTypeLiteral(type_lit) => {
for member in &type_lit.members {
let TSSignature::TSPropertySignature(prop) = member else {
continue;
};
let Some(property_name) = prop.key.static_name() else {
continue;
};
let path = if let Some(prefix) = prefix {
format!("{prefix}.{}", property_name.text())
} else {
property_name.text().into_owned()
};
let Some(type_annotation) = prop.type_annotation.as_deref() else {
continue;
};
if let Some(type_name) = extract_type_annotation_name(type_annotation) {
bindings.push((
path,
type_name,
extract_type_reference_origin(&type_annotation.type_annotation),
));
} else {
collect_nested_type_bindings(
&type_annotation.type_annotation,
Some(path.as_str()),
bindings,
);
}
}
}
TSType::TSParenthesizedType(paren) => {
collect_nested_type_bindings(&paren.type_annotation, prefix, bindings);
}
_ => {}
}
}
#[must_use]
pub fn extract_class_instance_bindings<F>(
class: &Class<'_>,
is_named_import_from: F,
) -> Vec<(String, String)>
where
F: Fn(&str, &str, &str) -> bool,
{
extract_class_instance_bindings_with_origins(class, is_named_import_from).0
}
pub(super) fn extract_class_instance_bindings_with_origins<F>(
class: &Class<'_>,
is_named_import_from: F,
) -> (Vec<(String, String)>, FxHashMap<String, Span>)
where
F: Fn(&str, &str, &str) -> bool,
{
let type_param_constraints = collect_class_type_param_constraints(class);
let resolve = |raw: String| -> Option<String> {
if let Some(replacement) = type_param_constraints.get(raw.as_str()) {
return replacement.clone();
}
Some(raw)
};
let constraints = collect_class_type_param_constraint_origins(class);
let resolve_origin = |ty: &TSType<'_>| -> Option<Span> {
let name = extract_type_reference_name(ty)?;
match constraints.get(&name) {
Some(Some(target)) => target.reference_span,
Some(None) => None,
None => extract_type_reference_origin(ty),
}
};
let mut origins = FxHashMap::default();
let mut bindings: Vec<(String, String)> = Vec::new();
for element in &class.body.body {
match element {
ClassElement::MethodDefinition(method) => {
if matches!(method.kind, MethodDefinitionKind::Constructor) {
collect_constructor_param_bindings(
method,
&resolve,
&resolve_origin,
&mut bindings,
&mut origins,
);
} else if matches!(method.kind, MethodDefinitionKind::Get) {
collect_getter_binding(
method,
&resolve,
&resolve_origin,
&mut bindings,
&mut origins,
);
} else if matches!(method.kind, MethodDefinitionKind::Method) {
collect_method_return_binding(class, method, &resolve, &mut bindings);
}
}
ClassElement::PropertyDefinition(prop) => {
let before = bindings.len();
collect_property_binding(prop, &resolve, &is_named_import_from, &mut bindings);
let origin = prop
.type_annotation
.as_deref()
.and_then(|ty| resolve_origin(&ty.type_annotation))
.or_else(|| match prop.value.as_ref() {
Some(Expression::NewExpression(expr)) => match &expr.callee {
Expression::Identifier(id) => Some(id.span),
_ => None,
},
_ => None,
});
if let Some(origin) = origin {
for (name, _) in &bindings[before..] {
origins.insert(name.clone(), origin);
}
}
}
_ => {}
}
}
(bindings, origins)
}
#[must_use]
pub fn extract_super_class_type_args(class: &Class<'_>) -> Vec<String> {
let Some(type_args) = class
.heritage
.as_ref()
.and_then(|heritage| heritage.type_arguments.as_deref())
else {
return Vec::new();
};
type_args
.params
.iter()
.map(|ty| plain_type_reference_name(ty).unwrap_or_default())
.collect()
}
#[must_use]
pub fn extract_class_type_parameter_names(class: &Class<'_>) -> Vec<String> {
class
.type_parameters
.as_deref()
.map_or_else(Vec::new, |parameters| {
parameters
.params
.iter()
.map(|parameter| parameter.name.name.to_string())
.collect()
})
}
fn plain_type_reference_name(ty: &TSType<'_>) -> Option<String> {
let TSType::TSTypeReference(type_ref) = ty else {
return None;
};
if type_ref.type_arguments.is_some() {
return None;
}
match &type_ref.type_name {
TSTypeName::IdentifierReference(ident) => Some(ident.name.to_string()),
_ => None,
}
}
#[must_use]
pub fn extract_class_generic_instance_bindings(class: &Class<'_>) -> Vec<(String, usize)> {
let param_indices = class_type_param_indices(class);
if param_indices.is_empty() {
return Vec::new();
}
let mut bindings: Vec<(String, usize)> = Vec::new();
for element in &class.body.body {
match element {
ClassElement::MethodDefinition(method) => {
if matches!(method.kind, MethodDefinitionKind::Constructor) {
for param in &method.value.params.items {
let Some(accessibility) = param.accessibility else {
continue;
};
if matches!(accessibility, TSAccessibility::Private) {
continue;
}
let BindingPattern::BindingIdentifier(id) = ¶m.pattern else {
continue;
};
let Some(type_annotation) = param.type_annotation.as_deref() else {
continue;
};
push_generic_binding(
id.name.as_str(),
type_annotation,
¶m_indices,
&mut bindings,
);
}
} else if matches!(method.kind, MethodDefinitionKind::Get) {
if matches!(method.accessibility, Some(TSAccessibility::Private)) {
continue;
}
let Some(name) = method.key.static_name() else {
continue;
};
let Some(type_annotation) = method.value.return_type.as_deref() else {
continue;
};
push_generic_binding(
&name.text(),
type_annotation,
¶m_indices,
&mut bindings,
);
}
}
ClassElement::PropertyDefinition(prop) => {
if matches!(prop.accessibility, Some(TSAccessibility::Private)) {
continue;
}
let Some(name) = prop.key.static_name() else {
continue;
};
let Some(type_annotation) = prop.type_annotation.as_deref() else {
continue;
};
push_generic_binding(&name.text(), type_annotation, ¶m_indices, &mut bindings);
}
_ => {}
}
}
bindings
}
fn push_generic_binding(
field: &str,
type_annotation: &TSTypeAnnotation<'_>,
param_indices: &FxHashMap<String, usize>,
bindings: &mut Vec<(String, usize)>,
) {
let Some(type_name) = extract_type_annotation_name(type_annotation) else {
return;
};
if let Some(index) = param_indices.get(type_name.as_str()) {
bindings.push((field.to_string(), *index));
}
}
fn class_type_param_indices(class: &Class<'_>) -> FxHashMap<String, usize> {
let mut map = FxHashMap::default();
let Some(type_parameters) = class.type_parameters.as_deref() else {
return map;
};
for (index, param) in type_parameters.params.iter().enumerate() {
map.insert(param.name.name.to_string(), index);
}
map
}
fn collect_constructor_param_bindings(
method: &oxc_ast::ast::MethodDefinition<'_>,
resolve: &impl Fn(String) -> Option<String>,
resolve_origin: &impl Fn(&TSType<'_>) -> Option<Span>,
bindings: &mut Vec<(String, String)>,
origins: &mut FxHashMap<String, Span>,
) {
for param in &method.value.params.items {
let Some(accessibility) = param.accessibility else {
continue;
};
if matches!(accessibility, TSAccessibility::Private) {
continue;
}
let BindingPattern::BindingIdentifier(id) = ¶m.pattern else {
continue;
};
let Some(type_annotation) = param.type_annotation.as_deref() else {
continue;
};
push_array_element_binding(id.name.as_str(), type_annotation, resolve, bindings);
let Some(type_name) = extract_type_annotation_name(type_annotation) else {
continue;
};
let Some(resolved) = resolve(type_name) else {
continue;
};
if let Some(origin) = resolve_origin(&type_annotation.type_annotation) {
origins.insert(id.name.to_string(), origin);
}
bindings.push((id.name.to_string(), resolved));
}
}
fn collect_property_binding<F>(
prop: &oxc_ast::ast::PropertyDefinition<'_>,
resolve: &impl Fn(String) -> Option<String>,
is_named_import_from: &F,
bindings: &mut Vec<(String, String)>,
) where
F: Fn(&str, &str, &str) -> bool,
{
if matches!(prop.accessibility, Some(TSAccessibility::Private)) {
return;
}
let Some(name) = prop.key.static_name() else {
return;
};
if let Some(type_annotation) = prop.type_annotation.as_deref() {
push_array_element_binding(&name.text(), type_annotation, resolve, bindings);
}
if let Some(type_annotation) = prop.type_annotation.as_deref()
&& let Some(type_name) = extract_type_annotation_name(type_annotation)
{
if let Some(resolved) = resolve(type_name) {
bindings.push((name.text().into_owned(), resolved));
}
return;
}
if let Some(Expression::NewExpression(new_expr)) = &prop.value
&& let Expression::Identifier(callee) = &new_expr.callee
&& !is_builtin_constructor(callee.name.as_str())
{
bindings.push((name.text().into_owned(), callee.name.to_string()));
return;
}
if let Some(Expression::CallExpression(call)) = &prop.value
&& let Some(type_name) = extract_angular_inject_target(call, is_named_import_from)
{
bindings.push((name.text().into_owned(), type_name));
return;
}
if let Some(source) = prop.value.as_ref().and_then(value_alias_source) {
bindings.push((name.text().into_owned(), source.to_string()));
}
}
pub fn extract_angular_inject_target<F>(
call: &CallExpression<'_>,
is_named_import_from: &F,
) -> Option<String>
where
F: Fn(&str, &str, &str) -> bool,
{
let Expression::Identifier(callee) = &call.callee else {
return None;
};
if !is_named_import_from(callee.name.as_str(), "@angular/core", "inject") {
return None;
}
if let Some(type_arguments) = call.type_arguments.as_deref()
&& let Some(TSType::TSTypeReference(type_ref)) = type_arguments.params.first()
&& let Some(type_name) = type_name_root(&type_ref.type_name)
{
return Some(type_name);
}
let Some(Argument::Identifier(target)) = call.arguments.first() else {
return None;
};
Some(target.name.to_string())
}
fn type_name_root(name: &TSTypeName<'_>) -> Option<String> {
match name {
TSTypeName::IdentifierReference(ident) => Some(ident.name.to_string()),
TSTypeName::QualifiedName(qualified) => type_name_root(&qualified.left),
TSTypeName::ThisExpression(_) => None,
}
}
#[must_use]
pub fn collect_class_type_param_constraints(
class: &Class<'_>,
) -> FxHashMap<String, Option<String>> {
collect_class_type_param_constraint_origins(class)
.into_iter()
.map(|(name, target)| (name, target.map(|target| target.name)))
.collect()
}
pub(super) fn collect_class_type_param_constraint_origins(
class: &Class<'_>,
) -> FxHashMap<String, Option<super::TypePropertyTarget>> {
let mut map = FxHashMap::default();
let Some(type_parameters) = class.type_parameters.as_deref() else {
return map;
};
for param in &type_parameters.params {
let constraint_name = param
.constraint
.as_ref()
.and_then(extract_type_reference_name);
let target = constraint_name.map(|name| super::TypePropertyTarget {
name,
reference_span: param
.constraint
.as_ref()
.and_then(extract_type_reference_origin),
owner_span: None,
});
map.insert(param.name.name.to_string(), target);
}
map
}
#[must_use]
pub(super) fn extract_type_reference_origin(ty: &TSType<'_>) -> Option<Span> {
match heritage_names::unwrap_member_preserving_type(ty) {
TSType::TSTypeReference(reference) => match &reference.type_name {
TSTypeName::IdentifierReference(reference) => Some(reference.span),
_ => None,
},
TSType::TSParenthesizedType(parenthesized) => {
extract_type_reference_origin(&parenthesized.type_annotation)
}
TSType::TSUnionType(union) if extract_nullable_union_name(union).is_some() => {
union.types.iter().find_map(extract_type_reference_origin)
}
_ => None,
}
}
pub fn extract_type_reference_name(ty: &TSType<'_>) -> Option<String> {
match heritage_names::unwrap_member_preserving_type(ty) {
TSType::TSTypeReference(type_ref) => extract_type_name(&type_ref.type_name),
TSType::TSParenthesizedType(paren) => extract_type_reference_name(&paren.type_annotation),
TSType::TSUnionType(union) => extract_nullable_union_name(union),
_ => None,
}
}
fn extract_nullable_union_name(union: &oxc_ast::ast::TSUnionType<'_>) -> Option<String> {
let mut found: Option<String> = None;
for branch in &union.types {
match branch {
TSType::TSNullKeyword(_) | TSType::TSUndefinedKeyword(_) => {}
other => {
if found.is_some() {
return None;
}
found = Some(extract_type_reference_name(other)?);
}
}
}
found
}
fn decorator_path(expr: &Expression<'_>) -> String {
match expr {
Expression::Identifier(id) => id.name.to_string(),
Expression::StaticMemberExpression(member) => {
let object = decorator_path(&member.object);
if object.is_empty() {
String::new()
} else {
format!("{}.{}", object, member.property.name)
}
}
Expression::CallExpression(call) => decorator_path(&call.callee),
Expression::ParenthesizedExpression(paren) => decorator_path(&paren.expression),
_ => String::new(),
}
}
pub(super) fn is_meta_url_arg(arg: &Argument<'_>) -> bool {
if let Argument::StaticMemberExpression(member) = arg
&& member.property.name == "url"
&& matches!(
member.object,
Expression::ImportMeta(_) | Expression::NewTarget(_)
)
{
return true;
}
false
}
pub(super) fn ts_import_type_qualifier_root<'a>(
qualifier: &'a oxc_ast::ast::TSImportTypeQualifier<'a>,
) -> &'a str {
let mut current = qualifier;
loop {
match current {
oxc_ast::ast::TSImportTypeQualifier::Identifier(id) => return id.name.as_str(),
oxc_ast::ast::TSImportTypeQualifier::QualifiedName(qn) => current = &qn.left,
}
}
}
pub(super) fn escape_glob_literal(text: &str) -> String {
let mut escaped = String::with_capacity(text.len());
for character in text.chars() {
if matches!(character, '*' | '?' | '[' | ']' | '{' | '}' | '(') {
escaped.push('[');
escaped.push(character);
escaped.push(']');
} else {
escaped.push(character);
}
}
escaped
}
pub(super) fn extract_concat_parts(
expr: &BinaryExpression<'_>,
) -> Option<(String, Option<String>)> {
let prefix = escape_glob_literal(&extract_leading_string(&expr.left)?);
let suffix = extract_trailing_string(&expr.right).map(|suffix| escape_glob_literal(&suffix));
Some((prefix, suffix))
}
fn extract_leading_string(expr: &Expression<'_>) -> Option<String> {
match expr {
Expression::StringLiteral(lit) => Some(lit.value.text().into_owned()),
Expression::BinaryExpression(bin)
if bin.operator == oxc_ast::ast::BinaryOperator::Addition =>
{
extract_leading_string(&bin.left)
}
_ => None,
}
}
fn extract_trailing_string(expr: &Expression<'_>) -> Option<String> {
match expr {
Expression::StringLiteral(lit) => {
let s = lit.value.text().into_owned();
if s.is_empty() { None } else { Some(s) }
}
_ => None,
}
}
pub(super) fn regex_pattern_to_suffix(pattern: &str) -> Option<String> {
let p = pattern.strip_prefix('^').unwrap_or(pattern);
let p = p.strip_prefix(".*").unwrap_or(p);
let p = p.strip_prefix("\\.")?;
let p = p.strip_suffix('$')?;
if let Some(base) = p.strip_suffix('?') {
if base.chars().all(|c| c.is_ascii_alphanumeric()) && !base.is_empty() {
let without_last = &base[..base.len() - 1];
if without_last.is_empty() {
return None;
}
return Some(format!(".{{{without_last},{base}}}"));
}
return None;
}
if let Some(inner) = p.strip_prefix('(').and_then(|s| s.strip_suffix(')')) {
let exts: Vec<&str> = inner.split('|').collect();
if exts
.iter()
.all(|e| e.chars().all(|c| c.is_ascii_alphanumeric()) && !e.is_empty())
{
return Some(format!(".{{{}}}", exts.join(",")));
}
return None;
}
if p.chars().all(|c| c.is_ascii_alphanumeric()) && !p.is_empty() {
return Some(format!(".{p}"));
}
None
}
pub(super) fn try_extract_factory_new_class(arguments: &[Argument<'_>]) -> Option<String> {
factory_new_class_target(arguments).map(|(name, _)| name)
}
pub(super) fn try_extract_factory_new_class_origin(
arguments: &[Argument<'_>],
) -> Option<(String, Span)> {
let (name, origin) = factory_new_class_target(arguments)?;
Some((name, origin?))
}
fn factory_new_class_target(arguments: &[Argument<'_>]) -> Option<(String, Option<Span>)> {
for arg in arguments {
let executes = match arg {
Argument::ArrowFunctionExpression(arrow) => !arrow.r#async,
Argument::FunctionExpression(function) => !function.r#async && !function.generator,
_ => false,
};
let class_name = match arg {
Argument::ArrowFunctionExpression(arrow) => match &arrow.body {
ArrowFunctionBody::FunctionBody(body) => {
extract_new_class_from_return_body(&body.statements)
}
body => extract_new_class_from_expression(body.as_expression()?),
},
Argument::FunctionExpression(func) => {
extract_new_class_from_return_body(&func.body.as_ref()?.statements)
}
_ => None,
};
if let Some((name, origin)) = class_name
&& !is_builtin_constructor(&name)
{
return Some((name, executes.then_some(origin)));
}
}
None
}
fn extract_new_class_from_expression(expr: &Expression<'_>) -> Option<(String, Span)> {
if let Expression::NewExpression(new_expr) = expr
&& let Expression::Identifier(callee) = &new_expr.callee
{
return Some((callee.name.to_string(), callee.span));
}
None
}
fn extract_new_class_from_return_body(stmts: &[Statement<'_>]) -> Option<(String, Span)> {
for stmt in stmts.iter().rev() {
if let Statement::ReturnStatement(ret) = stmt
&& let Some(Expression::NewExpression(new_expr)) = &ret.argument
&& let Expression::Identifier(callee) = &new_expr.callee
{
return Some((callee.name.to_string(), callee.span));
}
}
None
}
#[cfg(all(test, not(miri)))]
#[path = "helpers_tests.rs"]
mod tests;
pub(super) fn finish_package_resolve_sites(sites: Vec<(String, Span)>) -> Box<[(String, u32)]> {
sites
.into_iter()
.map(|(package_name, span)| (package_name, span.start))
.collect()
}