Get one function's all parameters in one call

src/drivers/abstract-javascript.ts

@@ -2,11 +2,15 @@ import * as recast from "recast"
 import * as vscode from 'vscode'
 import { removeShebang, ParameterPosition, showVariadicNumbers } from "../utils"
 
-export function getParameterName(editor: vscode.TextEditor, position: vscode.Position, key: number, namedValue?: string) {
+export function getParameterNameList(editor: vscode.TextEditor, languageParameters: ParameterPosition[]): Promise<string[]> {
     return new Promise(async (resolve, reject) => {
         let isVariadic = false
         let parameters: any[]
-        const description: any = await vscode.commands.executeCommand<vscode.Hover[]>('vscode.executeHoverProvider', editor.document.uri, position)
+        const firstParameter = languageParameters[0]
+        const description: any = await vscode.commands.executeCommand<vscode.Hover[]>('vscode.executeHoverProvider', editor.document.uri, new vscode.Position(
+            firstParameter.expression.line,
+            firstParameter.expression.character
+        ))
         const shouldHideRedundantAnnotations = vscode.workspace.getConfiguration('inline-parameters').get('hideRedundantAnnotations')
 
         if (description && description.length > 0) {
@@ -46,51 +50,59 @@ export function getParameterName(editor: vscode.TextEditor, position: vscode.Pos
         if (!parameters) {
             return reject()
         }
-
-        if (isVariadic && key >= parameters.length - 1) {
-            let name = parameters[parameters.length - 1]
 
-            if (shouldHideRedundantAnnotations && name === namedValue) {
-                return reject()
-            }
+        let namedValueName = undefined;
+        const parametersLength = parameters.length;
+        for (let i = 0; i < languageParameters.length; i++) {
+            const parameter = languageParameters[i];
+            const key = parameter.key;
 
-            name = showVariadicNumbers(name, -parameters.length + 1 + key)
+            if (isVariadic && key >= parameters.length - 1) {
+                if (namedValueName === undefined) namedValueName = parameters[parameters.length - 1]
 
-            return resolve(name)
-        }
+                if (shouldHideRedundantAnnotations && namedValueName === parameter.namedValue) {
+                    parameters[i] = undefined
+                    continue;
+                }
+
+                parameters[i] = showVariadicNumbers(namedValueName, -parametersLength + 1 + key)
+                continue;
+            }
 
-        if (parameters[key]) {
-            let name = parameters[key]
+            if (parameters[key]) {
+                let name = parameters[key]
 
-            if (shouldHideRedundantAnnotations && name === namedValue) {
-                return reject()
+                if (shouldHideRedundantAnnotations && name === parameter.namedValue) {
+                    parameters[i] = undefined
+                }
+                continue;
             }
 
-            return resolve(name)
+            parameters[i] = undefined
+            continue;
         }
 
-        return reject()
+        return resolve(parameters)
     })
 }
 
 export function parse(code: string, options: any) {
     code = removeShebang(code)
     let javascriptAst: any = ''
-    let parameters: ParameterPosition[] = []
     const editor = vscode.window.activeTextEditor
 
     try {
         javascriptAst = recast.parse(code, options).program.body
     } catch (err) {
-        return parameters
+        return [];
     }
 
-    parameters = lookForFunctionCalls(editor, parameters, javascriptAst)
-
-    return parameters
+   return lookForFunctionCalls(editor, javascriptAst)
 }
 
-function lookForFunctionCalls(editor: vscode.TextEditor, parameters: ParameterPosition[], body: any): ParameterPosition[] {
+function lookForFunctionCalls(editor: vscode.TextEditor, body: any): ParameterPosition[][] {
+    let parameters:ParameterPosition[][] = [];
+
     let arr = []
 
     function getNodes(astNode, nodeArr) {
@@ -131,24 +143,27 @@ function lookForFunctionCalls(editor: vscode.TextEditor, parameters: ParameterPo
         }
     })
 
-    for (const call of calls) {
-        if (call.callee && call.callee.loc) {
+    calls.forEach((call, index) => {
+         if (call.callee && call.callee.loc) {
 
             if (call.arguments) {
                 const hideSingleParameters = vscode.workspace.getConfiguration('inline-parameters').get('hideSingleParameters')
 
                 if (hideSingleParameters && call.arguments.length === 1) {
-                    continue
+                    return;
                 }
 
                 const expression = getExpressionLoc(call)
-
-                call.arguments.forEach((argument: any, key: number) => {
-                    parameters.push(parseParam(argument, key, expression, editor))
-                })
+
+                if (call.arguments.length > 0) {
+                    parameters[index] = [];
+                    call.arguments.forEach((argument: any, key: number) => {
+                        parameters[index].push(parseParam(argument, key, expression, editor))
+                    })
+                }
             }
         }
-    }
+    })
 
     return parameters
 }

src/drivers/javascript.ts

@@ -1,5 +1,5 @@
 import { parse as abstractParse } from './abstract-javascript'
-export { getParameterName } from './abstract-javascript'
+export { getParameterNameList } from './abstract-javascript'
 
 export function parse(code: string) {
     return abstractParse(code, {

src/drivers/javascriptreact.ts

@@ -1,5 +1,5 @@
 import { parse as abstractParse } from './abstract-javascript'
-export { getParameterName } from './abstract-javascript'
+export { getParameterNameList } from './abstract-javascript'
 
 export function parse(code: string) {
     return abstractParse(code, {

src/drivers/lua.ts

@@ -3,11 +3,15 @@ import { removeShebang, ParameterPosition } from '../utils'
 
 const parser = require('luaparse')
 
-export function getParameterName(editor: vscode.TextEditor, position: vscode.Position, key: number, namedValue?: string) {
+export function getParameterNameList(editor: vscode.TextEditor, languageParameters: ParameterPosition[]): Promise<string[]> {
     return new Promise(async (resolve, reject) => {
         let definition: string = ''
         let definitions: string[]
-        const description: any = await vscode.commands.executeCommand<vscode.Hover[]>('vscode.executeHoverProvider', editor.document.uri, position)
+        const firstParameter = languageParameters[0]
+        const description: any = await vscode.commands.executeCommand<vscode.Hover[]>('vscode.executeHoverProvider', editor.document.uri, new vscode.Position(
+            firstParameter.expression.line,
+            firstParameter.expression.character
+        ))
         const shouldHideRedundantAnnotations = vscode.workspace.getConfiguration('inline-parameters').get('hideRedundantAnnotations')
         const luaParameterNameRegex = /^[a-zA-Z_]([0-9a-zA-Z_]+)?/g
 
@@ -42,31 +46,40 @@ export function getParameterName(editor: vscode.TextEditor, position: vscode.Pos
             })
             .filter(parameter => parameter)
 
-        if (!parameters || !parameters[key]) {
-            return reject()
-        }
+        parameters.filter((param, index) => {
+            const parameter = languageParameters[index];
+            if (parameter === undefined) return false;
+            const key = parameter.key;
+            const namedValue = parameter.namedValue;
+
+            if (!parameters || !parameters[key]) {
+                return false
+            }
 
-        let name = parameters[key]
+            let name = parameters[key]
 
-        if (shouldHideRedundantAnnotations && name === namedValue) {
-            return reject()
-        }
+            if (shouldHideRedundantAnnotations && name === namedValue) {
+                return false
+            }
+
+            return true
+        })
 
-        return resolve(name)
+        return resolve(parameters);
     })
 }
 
-export function parse(code: string): ParameterPosition[] {
+export function parse(code: string): ParameterPosition[][] {
     code = removeShebang(code)
     const ast: any = parser.parse(code, {
         comments: false,
         locations: true,
     })
     const functionCalls: any[] = crawlAst(ast)
-    let parameters: ParameterPosition[] = []
+    let parameters: ParameterPosition[][] = []
 
     functionCalls.forEach((expression) => {
-        parameters = getParametersFromExpression(expression, parameters)
+        parameters.push(getParametersFromExpression(expression))
     })
 
     return parameters
@@ -94,11 +107,13 @@ function crawlAst(ast, functionCalls = []) {
     return functionCalls
 }
 
-function getParametersFromExpression(expression: any, parameters: ParameterPosition[] = []): ParameterPosition[] {
+function getParametersFromExpression(expression: any): ParameterPosition[] | undefined {
     if (!expression.arguments) {
-        return parameters
+        return undefined;
     }
 
+    let parameters = [];
+
     expression.arguments.forEach((argument: any, key: number) => {
         parameters.push({
             namedValue: argument.name ?? null,

src/drivers/php.ts

@@ -16,11 +16,15 @@ const parser = new engine({
     },
 })
 
-export function getParameterName(editor: vscode.TextEditor, position: vscode.Position, key: number, namedValue?: string) {
+export function getParameterNameList(editor: vscode.TextEditor, languageParameters: ParameterPosition[]): Promise<string[]> {
     return new Promise(async (resolve, reject) => {
         let isVariadic = false
         let parameters: any []
-        const description: any = await vscode.commands.executeCommand<vscode.Hover[]>('vscode.executeHoverProvider', editor.document.uri, position)
+        const firstParameter = languageParameters[0]
+        const description: any = await vscode.commands.executeCommand<vscode.Hover[]>('vscode.executeHoverProvider', editor.document.uri, new vscode.Position(
+            firstParameter.expression.line,
+            firstParameter.expression.character
+        ))
         const shouldHideRedundantAnnotations = vscode.workspace.getConfiguration('inline-parameters').get('hideRedundantAnnotations')
 
         if (description && description.length > 0) {
@@ -45,43 +49,55 @@ export function getParameterName(editor: vscode.TextEditor, position: vscode.Pos
             return parameter
         })
 
-        if (isVariadic && key >= parameters.length - 1) {
-            let name = parameters[parameters.length - 1]
-
-            if (shouldHideRedundantAnnotations && name.replace('$', '') === namedValue) {
-                return reject()
+        let namedValueName = undefined;
+        const parametersLength = parameters.length;
+        for (let i = 0; i < languageParameters.length; i++) {
+            const parameter = languageParameters[i];
+            const key = parameter.key;
+
+            if (isVariadic && key >= parameters.length - 1) {
+                if (namedValueName === undefined) namedValueName = parameters[parameters.length - 1]
+
+                if (shouldHideRedundantAnnotations && namedValueName.replace('$', '') === parameter.namedValue) {
+                    return reject()
+                }
+
+                let name = namedValueName;
+                name = showDollar(name)
+                parameters[i] = showVariadicNumbers(name, -parametersLength + 1 + key)
+                continue;
             }
 
-            name = showDollar(name)
-            name = showVariadicNumbers(name, -parameters.length + 1 + key)
+            if (parameters[key]) {
+                let name = parameters[key]
 
-            return resolve(name)
-        }
+                if (shouldHideRedundantAnnotations && name.replace('$', '') === parameter.namedValue) {
+                    parameters[i] = undefined
+                    continue;
+                }
 
-        if (parameters[key]) {
-            let name = parameters[key]
+                name = showDollar(name)
 
-            if (shouldHideRedundantAnnotations && name.replace('$', '') === namedValue) {
-                return reject()
+                parameters[i] = name
+                continue;
             }
-
-            name = showDollar(name)
-
-            return resolve(name)
+
+            parameters[i] = undefined
+            continue;
         }
-
-        return reject()
+        
+        return resolve(parameters);
     })
 }
 
-export function parse(code: string): ParameterPosition[] {
+export function parse(code: string): ParameterPosition[][] {
     code = removeShebang(code).replace("<?php", "")
     const ast: any = parser.parseEval(code)
     const functionCalls: any[] = crawlAst(ast)
-    let parameters: ParameterPosition[] = []
+    let parameters: ParameterPosition[][] = []
 
     functionCalls.forEach((expression) => {
-        parameters = getParametersFromExpression(expression, parameters)
+        parameters.push(getParametersFromExpression(expression))
     })
 
     return parameters
@@ -113,11 +129,13 @@ function crawlAst(ast, functionCalls = []) {
     return functionCalls
 }
 
-function getParametersFromExpression(expression: any, parameters: ParameterPosition[] = []): ParameterPosition[] {
+function getParametersFromExpression(expression: any): ParameterPosition[] | undefined {
     if (!expression.arguments) {
-        return parameters
+        return undefined
     }
 
+    let parameters = [];
+
     expression.arguments.forEach((argument: any, key: number) => {
         if (!expression.what || (!expression.what.offset && !expression.what.loc)) {
             return

src/drivers/typescript.ts

@@ -1,5 +1,5 @@
 import { parse as abstractParse } from './abstract-javascript'
-export { getParameterName } from './abstract-javascript'
+export { getParameterNameList } from './abstract-javascript'
 
 export function parse(code: string) {
     return abstractParse(code, {

src/drivers/typescriptreact.ts

@@ -1,5 +1,5 @@
 import { parse as abstractParse } from './abstract-javascript'
-export { getParameterName } from './abstract-javascript'
+export { getParameterNameList } from './abstract-javascript'
 
 export function parse(code: string) {
     return abstractParse(code, {