Adjust bracket positioning in SQL hover provider

src/language/providers/hoverProvider.ts

@@ -6,8 +6,8 @@ import Statement from "../../database/statement";
 import { getParmAttributes, prepareParamType } from "./logic/completion";
 import { StatementType } from "../sql/types";
 import { remoteAssistIsEnabled } from "./logic/available";
-import { getPositionData } from "./logic/callable";
 import { CallableSignature } from "../../database/callable";
+import { getPositionData } from "../sql/document";
 
 // =================================
 // We need to open provider to exist so symbols can be cached for hover support when opening files
@@ -87,16 +87,29 @@ export const hoverProvider = languages.registerHoverProvider({ language: `sql` }
 
           if (result) {
             if ('routine' in result) {
-              const routineOffset = ref.tokens[ref.tokens.length-1].range.end+1;
-              const callableRef = statementAt.getCallableDetail(routineOffset, false);
-              if (callableRef) {
-                const { currentCount } = getPositionData(callableRef, routineOffset);
-                const signatures = await DbCache.getCachedSignatures(callableRef.parentRef.object.schema, callableRef.parentRef.object.name);
-                const possibleSignatures = signatures.filter((s) => s.parms.length >= currentCount).sort((a, b) => a.parms.length - b.parms.length);
-                const signature = possibleSignatures.find((signature) => currentCount <= signature.parms.length);
-                if (signature) {
-                  addRoutineMd(md, signature, result);
-                }
+              let signatures: CallableSignature[];
+              let signature: CallableSignature | undefined;
+
+              const lastToken = ref.tokens[ref.tokens.length-1];
+
+              if (lastToken.type === `closebracket`) {
+                let routineOffset: number = lastToken.range.start-1;
+                const callableRef = statementAt.getCallableDetail(routineOffset, false);
+                if (callableRef) {
+                  const { currentCount } = getPositionData(callableRef, routineOffset);
+                  signatures = await DbCache.getCachedSignatures(callableRef.parentRef.object.schema, callableRef.parentRef.object.name);
+                  const possibleSignatures = signatures.filter((s) => s.parms.length >= currentCount).sort((a, b) => a.parms.length - b.parms.length);
+                  signature = possibleSignatures.find((signature) => currentCount <= signature.parms.length);
+                } 
+              }
+
+              if (!signature) {
+                signatures = await DbCache.getCachedSignatures(result.routine.schema, result.routine.name);
+                signature = signatures[0];
+              }
+
+              if (signature) {
+                addRoutineMd(md, signature, result);
               }
             } else {
               addSymbol(md, result);

src/language/providers/logic/callable.ts

@@ -5,6 +5,7 @@ import Statement from "../../../database/statement";
 import { createCompletionItem, getParmAttributes } from "./completion";
 import { DbCache } from "./cache";
 import { SQLParm } from "../../../types";
+import { getPositionData } from "../../sql/document";
 
 /**
  * Checks if the ref exists as a procedure or function. Then,
@@ -117,27 +118,4 @@ export function getCallableParameters(ref: CallableReference, offset: number): C
     });
   }
   return [];
-}
-
-export function getPositionData(ref: CallableReference, offset: number) {
-  const paramCommas = ref.tokens.filter(token => token.type === `comma`);
-
-  let currentParm = paramCommas.findIndex(t => offset < t.range.end);
-
-  if (currentParm === -1) {
-    currentParm = paramCommas.length;
-  }
-
-  const firstNamedPipe = ref.tokens.find((token, i) => token.type === `rightpipe`);
-  let firstNamedParameter = firstNamedPipe ? paramCommas.findIndex((token, i) => token.range.start > firstNamedPipe.range.start) : undefined;
-
-  if (firstNamedParameter === -1) {
-    firstNamedParameter = undefined;
-  }
-
-  return {
-    currentParm,
-    currentCount: paramCommas.length + 1,
-    firstNamedParameter
-  };
 }

src/language/providers/parameterProvider.ts

@@ -1,8 +1,8 @@
 import { MarkdownString, ParameterInformation, Position, Range, SignatureHelp, SignatureInformation, TextEdit, languages } from "vscode";
 import Statement from "../../database/statement";
-import Document from "../sql/document";
-import { getCallableParameters, getPositionData, isCallableType } from "./logic/callable";
-import { getParmAttributes, prepareParamType } from "./logic/completion";
+import Document, { getPositionData } from "../sql/document";
+import { isCallableType } from "./logic/callable";
+import { prepareParamType } from "./logic/completion";
 import { CallableType } from "../../database/callable";
 import { StatementType } from "../sql/types";
 import { remoteAssistIsEnabled } from "./logic/available";
@@ -22,7 +22,7 @@ export const signatureProvider = languages.registerSignatureHelpProvider({ langu
       const currentStatement = sqlDoc.getStatementByOffset(offset);
 
       if (currentStatement) {
-        const routineType: CallableType = currentStatement.type === StatementType.Call ? `PROCEDURE` : `FUNCTION`;
+        const routineType: CallableType = currentStatement. type === StatementType.Call ? `PROCEDURE` : `FUNCTION`;
         const callableRef = currentStatement.getCallableDetail(offset, true);
         // TODO: check the function actually exists before returning
         if (callableRef) {

src/language/sql/document.ts

@@ -1,6 +1,6 @@
 import Statement from "./statement";
 import SQLTokeniser from "./tokens";
-import { Definition, IRange, ParsedEmbeddedStatement, StatementGroup, StatementType, StatementTypeWord, Token } from "./types";
+import { CallableReference, Definition, IRange, ParsedEmbeddedStatement, StatementGroup, StatementType, StatementTypeWord, Token } from "./types";
 
 export default class Document {
   content: string;
@@ -261,6 +261,30 @@ export default class Document {
   }
 }
 
+
+export function getPositionData(ref: CallableReference, offset: number) {
+  const paramCommas = ref.tokens.filter(token => token.type === `comma`);
+
+  let currentParm = paramCommas.findIndex(t => offset < t.range.start);
+
+  if (currentParm === -1) {
+    currentParm = paramCommas.length;
+  }
+
+  const firstNamedPipe = ref.tokens.find((token, i) => token.type === `rightpipe`);
+  let firstNamedParameter = firstNamedPipe ? paramCommas.findIndex((token, i) => token.range.start > firstNamedPipe.range.start) : undefined;
+
+  if (firstNamedParameter === -1) {
+    firstNamedParameter = undefined;
+  }
+
+  return {
+    currentParm,
+    currentCount: paramCommas.length + 1,
+    firstNamedParameter
+  };
+}
+
 function getSymbolsForStatements(statements: Statement[]) {
   let defintions: Definition[] = [];
 

src/language/sql/statement.ts

@@ -117,7 +117,16 @@ export default class Statement {
 			if (tokenInOffset) {
 				if (tokenInOffset.type === `block`) {
 					if (tokenInOffset.block!.length > 0) {
-						return blockContainsOffset(cOffset, tokenInOffset.block!);
+						let blockRange = blockContainsOffset(cOffset, tokenInOffset.block!);
+						if (!blockRange) {
+							blockRange = {
+								start: this.tokens.findIndex(token => token.range.start === tokenInOffset.range.start) + 1,
+								end: this.tokens.findIndex(token => token.range.end === tokenInOffset.range.end)
+							}
+						}
+
+						return blockRange;
+
 					} else {
 						const rawEnd = this.tokens.findIndex(token => token.range.end === tokenInOffset.range.end);
 						return {
@@ -378,7 +387,7 @@ export default class Statement {
 		switch (this.type) {
 			case StatementType.Call:
 				// CALL X()
-				doAdd(this.getRefAtToken(1));
+				doAdd(this.getRefAtToken(1, {includeParameters: true}));
 				break;
 
 			case StatementType.Alter:
@@ -550,7 +559,7 @@ export default class Statement {
 
 		let endIndex = i;
 
-		const isSubSelect = tokenIs(nextToken, `function`, `TABLE`) || tokenIs(nextToken, `function`, `LATERAL`) || (options.includeParameters && tokenIs(nextToken, `function`));
+		const isSubSelect = (tokenIs(nextToken, `function`, `TABLE`) || tokenIs(nextToken, `function`, `LATERAL`) || (options.includeParameters && tokenIs(nextToken, `function`)) && this.type !== StatementType.Call);
 
 		if (isSubSelect) {
 			sqlObj = this.getRefAtToken(i+2);
@@ -598,7 +607,6 @@ export default class Statement {
 		}
 
 		if (sqlObj) {
-
 			if (options.withSystemName !== true) {
 				// If the next token is not a clause.. we might have the alias
 				if (nextToken && this.tokens[nextIndex+1]) {
@@ -615,6 +623,18 @@ export default class Statement {
 
 			if (!isSubSelect && !sqlObj.isUDTF) {
 				sqlObj.tokens = this.tokens.slice(i, endIndex+1);
+
+				if (options.includeParameters && tokenIs(this.tokens[endIndex+1], `openbracket`)) {
+					const blockTokens = this.getBlockAt(this.tokens[endIndex+1].range.end+1);
+
+					if (blockTokens.length > 0) {
+						sqlObj.tokens = sqlObj.tokens.concat([
+							{type: `openbracket`, value: `(`, range: {start: this.tokens[endIndex+1].range.start, end: this.tokens[endIndex+1].range.end}},
+							...blockTokens,
+							{type: `closebracket`, value: `)`, range: {start: blockTokens[blockTokens.length-1].range.end, end: blockTokens[blockTokens.length-1].range.end}}
+						]);
+					}
+				}
 			}
 
 			if (options.withSystemName) {

src/language/sql/tests/statements.test.ts

@@ -1,7 +1,7 @@
 import { assert, describe, expect, test } from 'vitest'
 import SQLTokeniser from '../tokens'
-import Document from '../document';
-import { ClauseType, StatementType } from '../types';
+import Document, { getPositionData } from '../document';
+import { CallableReference, ClauseType, StatementType } from '../types';
 
 const parserScenarios = describe.each([
   {newDoc: (content: string) => new Document(content)},
@@ -480,9 +480,13 @@ parserScenarios(`Object references`, ({newDoc}) => {
 
     const refsA = talksStatement.getObjectReferences();
     expect(refsA.length).toBe(1);
-    expect(refsA[0].tokens.length).toBe(1);
+
     expect(refsA[0].object.name).toBe(`create_Sql_sample`);
     expect(refsA[0].object.schema).toBeUndefined();
+
+    const tokens = refsA[0].tokens;
+    expect(tokens.length).toBe(4); // Includes the parameter tokens since it's a call
+    expect(tokens[tokens.length-1].type).toBe(`closebracket`);
   });
 
   test(`CALL: simple qualified`, () => {
@@ -498,9 +502,13 @@ parserScenarios(`Object references`, ({newDoc}) => {
 
     const refsA = talksStatement.getObjectReferences();
     expect(refsA.length).toBe(1);
-    expect(refsA[0].tokens.length).toBe(3);
+
     expect(refsA[0].object.name).toBe(`create_Sql_sample`);
     expect(refsA[0].object.schema).toBe(`"QSYS"`);
+
+    const tokens = refsA[0].tokens;
+    expect(tokens.length).toBe(6); // Includes the parameter tokens since it's a call
+    expect(tokens[tokens.length-1].type).toBe(`closebracket`);
   });
 
   test(`ALTER: with reference`, () => {
@@ -1995,6 +2003,112 @@ describe(`Parameter statement tests`, () => {
     expect(callableC.parentRef.object.schema).toBe(`qsys2`);
     expect(callableC.parentRef.object.name).toBe(`create_abcd`);
   });
+
+  test('Partial parameters 1: Position data for procedure call', () => {
+    const sql = `call qsys2.ifs_write('asdasd', )`;
+
+    const document = new Document(sql);
+    const statements = document.statements;
+
+    expect(statements.length).toBe(1);
+
+    const callableReference: CallableReference = statements[0].getCallableDetail(29);
+    expect(callableReference).toBeDefined();
+    expect(callableReference.parentRef.object.name).toBe(`ifs_write`);
+    expect(callableReference.parentRef.object.schema).toBe(`qsys2`);
+
+    const positionData = getPositionData(callableReference, 29);
+    expect(positionData).toBeDefined();
+
+    expect(positionData.currentParm).toBe(1);
+    expect(positionData.currentCount).toBe(2);
+  });
+
+  test('Partial parameters 1.2: Position data for procedure call', () => {
+    const sql = `call qsys2.ifs_write('asdasd', )`;
+
+    const document = new Document(sql);
+    const statements = document.statements;
+
+    expect(statements.length).toBe(1);
+
+    const callableReference: CallableReference = statements[0].getCallableDetail(31);
+    expect(callableReference).toBeDefined();
+    expect(callableReference.parentRef.object.name).toBe(`ifs_write`);
+    expect(callableReference.parentRef.object.schema).toBe(`qsys2`);
+
+    const positionData = getPositionData(callableReference, 31);
+    expect(positionData).toBeDefined();
+
+    expect(positionData.currentParm).toBe(1);
+    expect(positionData.currentCount).toBe(2);
+  });
+
+  test('Partial parameters 2: Position data for procedure call', () => {
+    const sql = `call qsys2.ifs_write('asdasd', 243)`;
+
+    const document = new Document(sql);
+    const statements = document.statements;
+
+    expect(statements.length).toBe(1);
+
+    const callableReference: CallableReference = statements[0].getCallableDetail(25);
+    expect(callableReference).toBeDefined();
+    expect(callableReference.parentRef.object.name).toBe(`ifs_write`);
+    expect(callableReference.parentRef.object.schema).toBe(`qsys2`);
+
+    const positionData = getPositionData(callableReference, 25);
+    expect(positionData).toBeDefined();
+
+    expect(positionData.currentParm).toBe(0);
+    expect(positionData.currentCount).toBe(2);
+  });
+
+  test('Partial parameters 3: Position data for procedure call', () => {
+    const sql = `call qsys2.ifs_write('asdasd', 243, )`;
+
+    const document = new Document(sql);
+    const statements = document.statements;
+
+    expect(statements.length).toBe(1);
+
+    const callableReference: CallableReference = statements[0].getCallableDetail(25);
+    expect(callableReference).toBeDefined();
+    expect(callableReference.parentRef.object.name).toBe(`ifs_write`);
+    expect(callableReference.parentRef.object.schema).toBe(`qsys2`);
+
+    const positionDataA = getPositionData(callableReference, 25);
+    expect(positionDataA).toBeDefined();
+
+    expect(positionDataA.currentParm).toBe(0);
+    expect(positionDataA.currentCount).toBe(3);
+
+    const positionDataB = getPositionData(callableReference, 29);
+    expect(positionDataB).toBeDefined();
+
+    expect(positionDataB.currentParm).toBe(1);
+    expect(positionDataB.currentCount).toBe(3);
+  });
+
+  test('Partial parameters 4: Position data for procedure call', () => {
+    const sql = `call qsys2.ifs_write('asdasd', 'asdasd', overwrite => 'asdad')`;
+
+    const document = new Document(sql);
+    const statements = document.statements;
+
+    expect(statements.length).toBe(1);
+
+    const callableReference: CallableReference = statements[0].getCallableDetail(50);
+    expect(callableReference).toBeDefined();
+    expect(callableReference.parentRef.object.name).toBe(`ifs_write`);
+    expect(callableReference.parentRef.object.schema).toBe(`qsys2`);
+
+    const positionDataA = getPositionData(callableReference, 50);
+    expect(positionDataA).toBeDefined();
+
+    expect(positionDataA.currentParm).toBe(2);
+    expect(positionDataA.currentCount).toBe(3);
+  });
 });
 
 describe(`Prefix tests`, () => {