diff --git a/src/drivers/abstract-javascript.ts b/src/drivers/abstract-javascript.ts
index e3d2366..89baa69 100644
--- a/src/drivers/abstract-javascript.ts
+++ b/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
 }
diff --git a/src/drivers/javascript.ts b/src/drivers/javascript.ts
index afe3859..ceae3b9 100644
--- a/src/drivers/javascript.ts
+++ b/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, {
diff --git a/src/drivers/javascriptreact.ts b/src/drivers/javascriptreact.ts
index 73232fb..2e09fff 100644
--- a/src/drivers/javascriptreact.ts
+++ b/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, {
diff --git a/src/drivers/lua.ts b/src/drivers/lua.ts
index ca3daab..c99c133 100644
--- a/src/drivers/lua.ts
+++ b/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,
diff --git a/src/drivers/php.ts b/src/drivers/php.ts
index be75c2e..1102fc0 100644
--- a/src/drivers/php.ts
+++ b/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
diff --git a/src/drivers/typescript.ts b/src/drivers/typescript.ts
index 8b7861b..b4359c1 100644
--- a/src/drivers/typescript.ts
+++ b/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, {
diff --git a/src/drivers/typescriptreact.ts b/src/drivers/typescriptreact.ts
index 7e80226..35e0405 100644
--- a/src/drivers/typescriptreact.ts
+++ b/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, {
diff --git a/src/extension.ts b/src/extension.ts
index f0ccf89..353046b 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -30,71 +30,73 @@ async function updateDecorations(activeEditor, languageDrivers: Record<string, L
     }
 
     const code = activeEditor.document.getText()
-    let languageParameters: ParameterPosition[] = []
+    let functionParametersList: ParameterPosition[][]
 
     try {
-        languageParameters = driver.parse(code)
+        functionParametersList = driver.parse(code)
     } catch (err) {
         // Error parsing language's AST, likely a syntax error on the user's side
     }
 
-    if (languageParameters.length === 0) {
+    if (functionParametersList.length === 0) {
         return
     }
 
     const languageFunctions: vscode.DecorationOptions[] = []
 
-    for (let index = 0; index < languageParameters.length; index++) {
-        var parameter = languageParameters[index]
+    const leadingCharacters = vscode.workspace.getConfiguration('inline-parameters').get('leadingCharacters')
+    const trailingCharacters = vscode.workspace.getConfiguration('inline-parameters').get('trailingCharacters')
+    const parameterCase = vscode.workspace.getConfiguration('inline-parameters').get('parameterCase')
 
-        const start = new vscode.Position(
-            parameter.start.line,
-            parameter.start.character
-        )
+    for (const languageParameters of functionParametersList) {
+        if (languageParameters === undefined) continue;
 
-        const end = new vscode.Position(
-            parameter.end.line,
-            parameter.end.character
-        )
-
-        let parameterName: any
+        let parameters;
 
         try {
-            parameterName = await driver.getParameterName(
+            parameters = await driver.getParameterNameList(
                 activeEditor,
-                new vscode.Position(
-                    parameter.expression.line,
-                    parameter.expression.character
-                ),
-                parameter.key,
-                parameter.namedValue
+                languageParameters
             )
         } catch (err) {
-            // Error getting a parameter name, just ignore it
+            continue;
         }
 
-        if (!parameterName) {
-            continue
-        }
-    
-        const leadingCharacters = vscode.workspace.getConfiguration('inline-parameters').get('leadingCharacters')
-        const trailingCharacters = vscode.workspace.getConfiguration('inline-parameters').get('trailingCharacters')
-        const parameterCase = vscode.workspace.getConfiguration('inline-parameters').get('parameterCase')
+        for (let index = 0; index < languageParameters.length; index++) {
+            let parameterName = parameters[index]
+            let parameter = languageParameters[index]
 
-        if (parameterCase === 'uppercase') {
-            parameterName = parameterName.toUpperCase()
-        }
+            if (parameterName === undefined) continue; 
 
-        if (parameterCase === 'lowercase') {
-            parameterName = parameterName.toLowerCase()
-        }
+            const start = new vscode.Position(
+                parameter.start.line,
+                parameter.start.character
+            )
+
+            const end = new vscode.Position(
+                parameter.end.line,
+                parameter.end.character
+            )
 
-        const annotation = Annotations.parameterAnnotation(
-            leadingCharacters + parameterName + trailingCharacters,
-            new vscode.Range(start, end)
-        )
+            if (!parameterName) {
+                continue
+            }
+        
+            if (parameterCase === 'uppercase') {
+                parameterName = parameterName.toUpperCase()
+            }
+
+            if (parameterCase === 'lowercase') {
+                parameterName = parameterName.toLowerCase()
+            }
+
+            const annotation = Annotations.parameterAnnotation(
+                leadingCharacters + parameterName + trailingCharacters,
+                new vscode.Range(start, end)
+            )
 
-        languageFunctions.push(annotation)
+            languageFunctions.push(annotation)
+        }    
     }
 
     activeEditor.setDecorations(hintDecorationType, languageFunctions)
diff --git a/src/utils.ts b/src/utils.ts
index 928820b..46b9863 100644
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -22,8 +22,8 @@ export interface ParameterPosition {
 }
 
 export interface LanguageDriver {
-    getParameterName(editor: vscode.TextEditor, position: vscode.Position, key: number, namedValue?: string): any
-    parse(code: string): ParameterPosition[]
+    getParameterNameList(editor: vscode.TextEditor, languageParameters: ParameterPosition[]): Promise<(string | undefined)[]>
+    parse(code: string): ParameterPosition[][]
 }
 
 export function removeShebang(sourceCode: string): string {