Added detection of destructured object parameters

Author: SebastianWendorf

typescript/src/core/processors/function-declaration.processor.ts

@@ -101,7 +101,7 @@ export class FunctionDeclarationProcessor extends Processor {
  */
 export class FunctionParameterProcessor extends Processor {
     public executionCondition: ExecutionCondition = new ExecutionCondition(
-        [AST_NODE_TYPES.Identifier], // TODO: add other parameter patterns
+        [AST_NODE_TYPES.Identifier, AST_NODE_TYPES.ObjectPattern], // TODO: add other parameter patterns
         ({localContexts}) =>
             !!localContexts.parentContexts && localContexts.parentContexts.has(CoreContextKeys.FUNCTION_TYPE)
     );
@@ -119,12 +119,13 @@ export class FunctionParameterProcessor extends Processor {
                     const funcTypeParam = functionType.parameters[paramIndex];
 
                     // TODO: handle function overloads: funcTypeParam must always be defined!
-                    if (funcTypeParam && node.type === AST_NODE_TYPES.Identifier) {
+                    if (funcTypeParam) {
+                        const paramName = node.type === AST_NODE_TYPES.Identifier ? funcTypeParam.name : "";
                         return singleEntryConceptMap(
                             LCEParameterDeclaration.conceptId,
                             new LCEParameterDeclaration(
                                 funcTypeParam.index,
-                                funcTypeParam.name,
+                                paramName,
                                 funcTypeParam.type,
                                 "optional" in node && !!node.optional,
                                 getAndDeleteChildConcepts(IdentifierTraverser.DECORATORS_PROP, LCEDecorator.conceptId, childConcepts),

typescript/test/core/integration/function-declarations.test.ts

@@ -255,6 +255,34 @@ describe("function declarations test", () => {
         }
     });
 
+    test("function with single destructured parameter of referenced interface type", async () => {
+        const decl = funDecls.get('"./src/main.ts".fDestructuredParam');
+        expect(decl).toBeDefined();
+        if (decl) {
+            expect(decl.coordinates.fileName).toBe(mainModule.path);
+            expect(decl.fqn.globalFqn).toBe(resolveGlobalFqn(projectRootPath, '"./src/main.ts".fDestructuredParam'));
+            expect(decl.functionName).toBe("fDestructuredParam");
+
+            expectPrimitiveType(decl.returnType, "void");
+
+            expect(decl.parameters).toHaveLength(1);
+            expectFunctionParameter(decl.parameters, 0, "", false);
+            expectDeclaredType(decl.parameters[0].type, resolveGlobalFqn(projectRootPath, '"./src/main.ts".CustomInterface'));
+
+            expect(decl.async).toBe(false);
+
+            expect(decl.typeParameters).toHaveLength(0);
+        }
+
+        expectDependency(
+            projectRootPath,
+            dependencies,
+            '"./src/main.ts".fDestructuredParam',
+            resolveGlobalFqn(projectRootPath, '"./src/main.ts".CustomInterface'),
+            1,
+        );
+    });
+
     test("function with single parameter of referenced class type", async () => {
         const decl = funDecls.get('"./src/main.ts".fParamRef');
         expect(decl).toBeDefined();

typescript/test/core/integration/sample-projects/function-declarations/src/main.ts

@@ -53,6 +53,7 @@ function fBodyRef() {
 
 function fParam(p1: number) {}
 function fMultiParam(p1: number, p2: string, p3?: string) {}
+function fDestructuredParam({x, y}: CustomInterface): void {}
 // function fParamDefault(p1: string = "") {} // TODO: enable this once default parameters are supported
 // function fSpread(...p1: number[]) {} // TODO: enable this once spread parameters are supported
 function fParamRef(p1: CustomClass) {}