Skip to content

refactor: module type and type member refactoring #6103

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
arendjr merged 2 commits into from
May 21, 2025
Merged

refactor: module type and type member refactoring #6103

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
4d355b1
refactor: module type and type member refactoring
arendjr May 21, 2025
1dbb596
More snapshot updates
arendjr May 21, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
58 changes: 29 additions & 29 deletions crates/biome_js_type_info/src/flattening.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4,7 +4,7 @@ use biome_rowan::Text;

use crate::{
DestructureField, GenericTypeParameter, ResolvedTypeData, ResolvedTypeMember, TypeData,
TypeInstance, TypeMember, TypeReference, TypeResolver, TypeofExpression,
TypeInstance, TypeMemberKind, TypeReference, TypeResolver, TypeofExpression,
TypeofStaticMemberExpression,
};

Expand Down Expand Up @@ -131,15 +131,14 @@ fn flattened(mut ty: TypeData, resolver: &mut dyn TypeResolver, depth: usize) ->
None => ty,
},
TypeData::Object(_) => {
let member = resolved
let member_ty = resolved
.all_members(resolver)
.find(|member| member.has_name("constructor"))
.map(ResolvedTypeMember::to_member);
match member {
Some(member) => {
ty = resolver
.type_from_member(resolved.to_data(), member)
.to_data();
.map(ResolvedTypeMember::to_member)
.and_then(|member| resolver.resolve_and_get(&member.ty));
match member_ty {
Some(member_ty) => {
ty = member_ty.to_data();
continue;
}
None => TypeData::unknown(),
Expand All @@ -160,15 +159,12 @@ fn flattened(mut ty: TypeData, resolver: &mut dyn TypeResolver, depth: usize) ->
Some(member) => {
ty = flattened(
resolver
.type_from_member(
resolved.to_data(),
ResolvedTypeMember::from((
resolved.resolver_id(),
member,
))
.to_member(),
.resolve_and_get(
&resolved
.apply_module_id_to_reference(&member.ty),
)
.to_data(),
.map(ResolvedTypeData::to_data)
.unwrap_or_default(),
resolver,
depth,
);
Expand Down Expand Up @@ -225,8 +221,9 @@ fn flattened(mut ty: TypeData, resolver: &mut dyn TypeResolver, depth: usize) ->
});
return match member {
Some(member) => resolver
.type_from_member(resolved.to_data(), member.to_member())
.to_data(),
.resolve_and_get(&member.ty())
.map(ResolvedTypeData::to_data)
.unwrap_or_default(),
None => TypeData::Unknown,
};
}
Expand Down Expand Up @@ -270,13 +267,19 @@ fn flattened(mut ty: TypeData, resolver: &mut dyn TypeResolver, depth: usize) ->
let constructed_ty = class
.members
.iter()
.find_map(|member| match member {
TypeMember::Constructor(constructor) => {
// TODO: We might need to make an attempt to match
// type signatures too.
(constructor.parameters.len() == num_args)
.then(|| constructor.return_type.clone())
.flatten()
.find_map(|member| match member.kind {
TypeMemberKind::Constructor => {
let constructor = resolver.resolve_and_get(&member.ty)?;
match constructor.as_raw_data() {
TypeData::Constructor(constructor) => {
// TODO: We might need to make an attempt to match
// type signatures too.
(constructor.parameters.len() == num_args)
.then(|| constructor.return_type.clone())
.flatten()
}
_ => None,
}
}
_ => None,
})
Expand Down Expand Up @@ -386,10 +389,7 @@ fn flattened(mut ty: TypeData, resolver: &mut dyn TypeResolver, depth: usize) ->
});
match member {
Some(member) => {
let member = member.to_member();
ty = TypeData::reference(
resolver.register_type_from_member(object.to_data(), member),
);
ty = TypeData::reference(member.ty().into_owned());
}
None => return TypeData::Unknown,
}
Expand Down
168 changes: 40 additions & 128 deletions crates/biome_js_type_info/src/format_type_info.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,10 +1,10 @@
use crate::globals::global_type_name;
use crate::{
CallArgumentType, CallSignatureTypeMember, Class, DestructureField, Function,
FunctionParameter, FunctionParameterBinding, GenericTypeParameter, ImportSymbol, Literal,
MethodTypeMember, NUM_PREDEFINED_TYPES, Object, ObjectLiteral, PropertyTypeMember, ReturnType,
Type, TypeData, TypeImportQualifier, TypeInstance, TypeMember, TypeReference,
TypeReferenceQualifier, TypeResolverLevel, TypeofAwaitExpression, TypeofExpression, Union,
CallArgumentType, Class, DestructureField, Function, FunctionParameter,
FunctionParameterBinding, GenericTypeParameter, ImportSymbol, Literal, NUM_PREDEFINED_TYPES,
Object, ObjectLiteral, ReturnType, Type, TypeData, TypeImportQualifier, TypeInstance,
TypeMember, TypeMemberKind, TypeReference, TypeReferenceQualifier, TypeResolverLevel,
TypeofAwaitExpression, TypeofExpression, Union,
};
use biome_formatter::prelude::*;
use biome_formatter::{
Expand Down Expand Up @@ -95,6 +95,7 @@ impl Format<FormatTypeContext> for TypeData {
Self::Class(class) => write!(f, [&class.as_ref()]),
Self::Constructor(ty) => write!(f, [FmtVerbatim(ty.as_ref())]),
Self::Function(function) => write!(f, [&function.as_ref()]),
Self::Module(ty) => write!(f, [FmtVerbatim(ty.as_ref())]),
Self::Namespace(ty) => write!(f, [FmtVerbatim(ty.as_ref())]),
Self::Object(object) => write!(f, [object.as_ref()]),
Self::Tuple(ty) => write!(f, [FmtVerbatim(&ty.as_ref())]),
Expand Down Expand Up @@ -142,9 +143,7 @@ impl Format<FormatTypeContext> for Object {
hard_line_break(),
text("members:"),
space(),
text("{"),
FmtTypeMembers(self.members.as_ref()),
text("}"),
])),
text("}")
]]
Expand Down Expand Up @@ -280,24 +279,35 @@ impl Format<FormatTypeContext> for FunctionParameter {

impl Format<FormatTypeContext> for TypeMember {
fn fmt(&self, f: &mut Formatter<FormatTypeContext>) -> FormatResult<()> {
match self {
Self::CallSignature(ty) => {
write!(
f,
[&format_args![
text("CallSignature"),
text("("),
&group(&soft_block_indent(&ty)),
text(")")
]]
)
}
Self::Constructor(ty) => write!(f, [FmtVerbatim(&ty)]),
Self::Method(method) => {
write!(f, [&format_args![&method]])
let format_static = format_with(|f| {
if self.is_static() {
write!(f, [text("static"), space()])
} else {
Ok(())
}
Self::Property(property) => {
write!(f, [&format_args![&property]])
});

write!(
f,
[&format_args![
format_static,
&self.kind,
text(":"),
space(),
&group(&soft_block_indent(&self.ty)),
]]
)
}
}

impl Format<FormatTypeContext> for TypeMemberKind {
fn fmt(&self, f: &mut Formatter<FormatTypeContext>) -> FormatResult<()> {
match self {
Self::CallSignature => write!(f, [text("()")]),
Self::Constructor => write!(f, [text("constructor")]),
Self::Named(name) => {
let quoted = std::format!("\"{name}\"");
write!(f, [dynamic_text(&quoted, TextSize::default())])
}
}
}
Expand All @@ -310,7 +320,7 @@ impl Format<FormatTypeContext> for TypeofAwaitExpression {
) -> FormatResult<()> {
write!(
f,
[&format_args![group(&soft_block_indent(&self.argument)),]]
[&format_args![group(&soft_block_indent(&self.argument))]]
)
}
}
Expand Down Expand Up @@ -398,102 +408,6 @@ impl Format<FormatTypeContext> for TypeofExpression {
}
}

impl Format<FormatTypeContext> for PropertyTypeMember {
fn fmt(&self, f: &mut Formatter<FormatTypeContext>) -> FormatResult<()> {
let is_optional = format_with(|f| {
if self.is_optional {
write!(f, [&format_args![text("optional")]])
} else {
write!(f, [&format_args![text("required")]])
}
});
write!(
f,
[&format_args![
is_optional,
space(),
text("property"),
space(),
dynamic_text(&std::format!("\"{}\"", &self.name), TextSize::default()),
text(":"),
space(),
group(&soft_block_indent(&self.ty))
]]
)
}
}

impl Format<FormatTypeContext> for MethodTypeMember {
fn fmt(&self, f: &mut Formatter<FormatTypeContext>) -> FormatResult<()> {
let is_async = format_with(|f| {
if self.is_async {
write!(f, [&format_args![text("async")]])
} else {
write!(f, [&format_args![text("sync")]])
}
});

let is_optional = format_with(|f| {
if self.is_optional {
write!(f, [&format_args![text("optional")]])
} else {
write!(f, [&format_args![text("required")]])
}
});
write!(
f,
[&format_args![
is_optional,
space(),
is_async,
space(),
text("method"),
space(),
dynamic_text(&std::format!("\"{}\"", &self.name), TextSize::default()),
space(),
text("{"),
&group(&soft_block_indent(&format_args![
text("accepts:"),
space(),
text("{"),
&group(&block_indent(&format_args![
text("params:"),
space(),
FmtFunctionParameters(&self.parameters),
hard_line_break(),
text("type_args:"),
space(),
FmtGenericTypeParameters(&self.type_parameters),
])),
text("}"),
hard_line_break(),
text("returns:"),
space(),
&self.return_type,
space(),
])),
text("}"),
]]
)
}
}

impl Format<FormatTypeContext> for CallSignatureTypeMember {
fn fmt(&self, f: &mut Formatter<FormatTypeContext>) -> FormatResult<()> {
write!(
f,
[&format_args![
FmtGenericTypeParameters(&self.type_parameters),
FmtFunctionParameters(&self.parameters),
text("ReturnType"),
text("("),
group(&soft_block_indent(&self.return_type)),
text(")")
]]
)
}
}

impl Format<FormatTypeContext> for GenericTypeParameter {
fn fmt(&self, f: &mut Formatter<FormatTypeContext>) -> FormatResult<()> {
write!(
Expand Down Expand Up @@ -835,22 +749,20 @@ struct FmtTypeMembers<'a>(&'a [TypeMember]);

impl Format<FormatTypeContext> for FmtTypeMembers<'_> {
fn fmt(&self, f: &mut Formatter<FormatTypeContext>) -> FormatResult<()> {
if self.0.is_empty() {
return Ok(());
}

write!(f, [&format_args![text("TypeMembers"), text("("),]])?;
write!(f, [text("[")])?;

let types = format_with(|f| {
let mut joiner = f.join_with(soft_line_break());
let separator =
format_with(|f| write!(f, [&format_args![text(","), soft_line_break_or_space()]]));
let mut joiner = f.join_with(separator);
for part in self.0 {
joiner.entry(&format_args![part]);
}
joiner.finish()
});
write!(
f,
[&format_args![group(&soft_block_indent(&types)), text(")")]]
[&format_args![group(&soft_block_indent(&types)), text("]")]]
)
}
}
Expand Down
Loading