implement destructuring of interfaces

Author: arendjr

crates/biome_js_type_info/src/flattening.rs

@@ -216,6 +216,50 @@ fn flattened(mut ty: TypeData, resolver: &mut dyn TypeResolver, depth: usize) ->
                                         .collect(),
                                 );
                             }
+                            (TypeData::Interface(interface), DestructureField::Name(name)) => {
+                                match interface.members.iter().find(|own_member| {
+                                    own_member.is_static() && own_member.has_name(name.text())
+                                }) {
+                                    Some(member) => {
+                                        ty = flattened(
+                                            resolver
+                                                .resolve_and_get(
+                                                    &resolved
+                                                        .apply_module_id_to_reference(&member.ty),
+                                                )
+                                                .map(ResolvedTypeData::to_data)
+                                                .unwrap_or_default(),
+                                            resolver,
+                                            depth,
+                                        );
+                                    }
+                                    None => return TypeData::reference(GLOBAL_UNKNOWN_ID),
+                                }
+                            }
+                            (
+                                TypeData::Interface(interface),
+                                DestructureField::RestExcept(names),
+                            ) => {
+                                return TypeData::object_with_members(
+                                    interface
+                                        .members
+                                        .iter()
+                                        .filter(|own_member| {
+                                            own_member.is_static()
+                                                && !names
+                                                    .iter()
+                                                    .any(|name| own_member.has_name(name))
+                                        })
+                                        .map(|member| {
+                                            ResolvedTypeMember::from((
+                                                resolved.resolver_id(),
+                                                member,
+                                            ))
+                                            .to_member()
+                                        })
+                                        .collect(),
+                                );
+                            }
                             (subject, DestructureField::Index(index)) => {
                                 return subject
                                     .clone()

crates/biome_js_type_info/src/helpers.rs

@@ -3,7 +3,7 @@ use std::borrow::Cow;
 use biome_rowan::Text;
 
 use crate::{
-    BindingId, Class, GenericTypeParameter, Module, Namespace, Object, ResolvedTypeData,
+    BindingId, Class, GenericTypeParameter, Interface, Module, Namespace, Object, ResolvedTypeData,
     ResolvedTypeId, ResolvedTypeMember, ResolverId, TypeData, TypeInstance, TypeReference,
     TypeResolver,
     globals::{GLOBAL_ARRAY_ID, GLOBAL_PROMISE_ID, GLOBAL_TYPE_MEMBERS},
@@ -243,6 +243,18 @@ impl<'a> Iterator for TypeMemberIterator<'a> {
                 }
             }
             Some(TypeMemberOwner::InstanceOf(instance_of)) => &instance_of.ty,
+            Some(TypeMemberOwner::Interface(interface)) => {
+                match interface.members.get(self.index) {
+                    Some(member) => {
+                        self.index += 1;
+                        return Some((self.resolver_id, member).into());
+                    }
+                    None => {
+                        self.owner = None;
+                        return None;
+                    }
+                }
+            }
             Some(TypeMemberOwner::Module(module)) => match module.members.get(self.index) {
                 Some(member) => {
                     self.index += 1;
@@ -322,6 +334,7 @@ enum TypeMemberOwner<'a> {
     Class(&'a Class),
     Global,
     InstanceOf(&'a TypeInstance),
+    Interface(&'a Interface),
     Module(&'a Module),
     Namespace(&'a Namespace),
     Object(&'a Object),
@@ -333,6 +346,7 @@ impl<'a> TypeMemberOwner<'a> {
             TypeData::Class(class) => Some(Self::Class(class)),
             TypeData::Global => Some(Self::Global),
             TypeData::InstanceOf(type_instance) => Some(Self::InstanceOf(type_instance)),
+            TypeData::Interface(interface) => Some(Self::Interface(interface)),
             TypeData::Module(module) => Some(Self::Module(module)),
             TypeData::Namespace(namespace) => Some(Self::Namespace(namespace)),
             TypeData::Object(object) => Some(Self::Object(object)),

crates/biome_js_type_info/tests/flattening.rs

@@ -4,7 +4,8 @@ use biome_js_type_info::{GlobalsResolver, TypeData};
 
 use utils::{
     HardcodedSymbolResolver, assert_type_data_snapshot, assert_typed_bindings_snapshot,
-    get_expression, get_function_declaration, get_variable_declaration, parse_ts,
+    get_expression, get_function_declaration, get_interface_declaration, get_variable_declaration,
+    parse_ts,
 };
 
 #[test]
@@ -221,3 +222,34 @@ fn infer_flattened_type_of_destructured_array_element() {
         "infer_flattened_type_of_destructured_array_element",
     );
 }
+
+#[test]
+fn infer_flattened_type_of_destructured_interface_field() {
+    const CODE: &str = r#"interface Foo {
+    foo(): string;
+}
+
+function bar({ foo }: Foo) {
+}"#;
+
+    let root = parse_ts(CODE);
+    let decl = get_interface_declaration(&root);
+    let mut resolver = GlobalsResolver::default();
+    let interface_ty = TypeData::from_ts_interface_declaration(&mut resolver, &decl)
+        .expect("interface must be inferred");
+    resolver.run_inference();
+
+    let function_decl = get_function_declaration(&root);
+    let mut resolver = HardcodedSymbolResolver::new("Foo", interface_ty, resolver);
+    let function_decl = TypeData::from_js_function_declaration(&mut resolver, &function_decl);
+    resolver.run_inference();
+
+    let expr_ty = function_decl.inferred(&mut resolver);
+
+    assert_type_data_snapshot(
+        CODE,
+        expr_ty,
+        &resolver,
+        "infer_flattened_type_of_destructured_interface_field",
+    )
+}

crates/biome_js_type_info/tests/snapshots/infer_flattened_type_of_destructured_interface_field.snap

@@ -0,0 +1,56 @@
+---
+source: crates/biome_js_type_info/tests/utils.rs
+expression: content
+---
+## Input
+
+```ts
+interface Foo {
+	foo(): string;
+}
+
+function bar({ foo }: Foo) {}
+
+```
+
+## Result
+
+```
+sync Function "bar" {
+  accepts: {
+    params: [
+      required (unnamed): Module(0) TypeId(1) (bindings: foo:Module(0) TypeId(1).foo)
+    ]
+    type_args: []
+  }
+  returns: unknown reference
+}
+```
+
+## Registered types
+
+```
+Module TypeId(0) => interface "Foo" {
+  extends: []
+  type_args: []
+  members: ["foo": Global TypeId(0)]
+}
+
+Module TypeId(1) => instanceof Module(0) TypeId(0)
+
+Module TypeId(2) => sync Function "foo" {
+  accepts: {
+    params: []
+    type_args: []
+  }
+  returns: string
+}
+
+Global TypeId(0) => sync Function "foo" {
+  accepts: {
+    params: []
+    type_args: []
+  }
+  returns: string
+}
+```

crates/biome_js_type_info/tests/utils.rs

@@ -3,7 +3,7 @@
 use biome_js_formatter::context::JsFormatOptions;
 use biome_js_formatter::format_node;
 use biome_js_parser::{JsParserOptions, parse};
-use biome_js_syntax::{AnyJsExpression, JsVariableDeclaration};
+use biome_js_syntax::{AnyJsExpression, JsVariableDeclaration, TsInterfaceDeclaration};
 use biome_js_syntax::{
     AnyJsModuleItem, AnyJsRoot, AnyJsStatement, JsFileSource, JsFunctionDeclaration,
 };
@@ -233,6 +233,22 @@ pub fn get_function_declaration(root: &AnyJsRoot) -> JsFunctionDeclaration {
         .expect("cannot find function declaration")
 }
 
+pub fn get_interface_declaration(root: &AnyJsRoot) -> TsInterfaceDeclaration {
+    let module = root.as_js_module().unwrap();
+    module
+        .items()
+        .into_iter()
+        .filter_map(|item| match item {
+            AnyJsModuleItem::AnyJsStatement(statement) => Some(statement),
+            _ => None,
+        })
+        .find_map(|statement| match statement {
+            AnyJsStatement::TsInterfaceDeclaration(decl) => Some(decl),
+            _ => None,
+        })
+        .expect("cannot find interface declaration")
+}
+
 pub fn get_variable_declaration(root: &AnyJsRoot) -> JsVariableDeclaration {
     let module = root.as_js_module().unwrap();
     module