Improved routine detail

Signed-off-by: worksofliam <[email protected]>

Author: worksofliam

global.d.ts

@@ -1,3 +1,4 @@
+// https://www.ibm.com/docs/en/i/7.4?topic=views-syscolumns2
 interface TableColumn {
   TABLE_SCHEMA: string,
   TABLE_NAME: string,
@@ -15,6 +16,7 @@ interface TableColumn {
   IS_IDENTITY: "YES" | "NO",
 }
 
+// https://www.ibm.com/docs/en/i/7.4?topic=views-sysparms
 interface SQLParm {
   SPECIFIC_SCHEMA: string,
   SPECIFIC_NAME: string,

src/language/providers/hoverProvider.ts

@@ -1,11 +1,13 @@
 import { Hover, languages, MarkdownString, workspace } from "vscode";
 import { getSqlDocument } from "./logic/parse";
-import { DbCache, LookupResult } from "./logic/cache";
+import { DbCache, LookupResult, RoutineDetail } from "./logic/cache";
 import { JobManager } from "../../config";
 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";
 
 // =================================
 // We need to open provider to exist so symbols can be cached for hover support when opening files
@@ -56,6 +58,8 @@ export const openProvider = workspace.onDidOpenTextDocument(async (document) =>
 
 export const hoverProvider = languages.registerHoverProvider({ language: `sql` }, {
   async provideHover(document, position, token) {
+    if (!remoteAssistIsEnabled()) return;
+    
     const defaultSchema = getDefaultSchema();
     const sqlDoc = getSqlDocument(document);
     const offset = document.offsetAt(position);
@@ -75,10 +79,23 @@ export const hoverProvider = languages.registerHoverProvider({ language: `sql` }
         if (atRef) {
           const schema = ref.object.schema || defaultSchema;
           const result = await lookupSymbol(ref.object.name, schema, possibleNames);
+
+
           if (result) {
-            addSymbol(md, result);
-          } else {
-            
+            if ('routine' in result) {
+              const callableRef = statementAt.getCallableDetail(offset, false);
+              if (callableRef) {
+                const { currentCount } = getPositionData(callableRef, offset);
+                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);
+                }
+              }
+            } else {
+              addSymbol(md, result);
+            }
           }
 
           if (systemSchemas.includes(schema.toUpperCase())) {
@@ -102,6 +119,39 @@ export const hoverProvider = languages.registerHoverProvider({ language: `sql` }
 
 const systemSchemas = [`QSYS`, `QSYS2`, `SYSTOOLS`];
 
+function addRoutineMd(base: MarkdownString, signature: CallableSignature, result: RoutineDetail) {
+  const returns = signature.returns.length > 0 ? `: ${signature.returns.length} column${signature.returns.length === 1 ? `` : `s`}` : '';
+
+  let codeLines: string[] = [`${Statement.prettyName(result.routine.name)}(`];
+
+  for (let i = 0; i < signature.parms.length; i++) {
+    const parm = signature.parms[i];
+    let parmString = `  ${Statement.prettyName(parm.PARAMETER_NAME || `parm${i + 1}`)} => ${prepareParamType(parm)}`;
+
+    if (i < signature.parms.length - 1) {
+      parmString += `,`;
+    }
+
+    codeLines.push(parmString);
+  }
+
+  codeLines.push(`)${returns}`);
+
+  base.appendCodeblock(codeLines.join(`\n`), `sql`);
+
+  let parmDetail = [``, `---`];
+
+  for (let i = 0; i < signature.parms.length; i++) {
+    const parm = signature.parms[i];
+    const escapedAsterisk = parm.LONG_COMMENT ? parm.LONG_COMMENT.replace(/\*/g, `\\*`) : ``;
+    parmDetail.push(``, `*@param* \`${Statement.prettyName(parm.PARAMETER_NAME || `parm${i}`)}\` ${escapedAsterisk}`);
+  }
+
+  parmDetail.push(``);
+
+  base.appendMarkdown(parmDetail.join(`\n`));
+}
+
 function addSearch(base: MarkdownString, value: string, withGap = true) {
   if (withGap) {
     base.appendMarkdown([``, `---`, ``].join(`\n`));
@@ -120,23 +170,7 @@ function addList(base: MarkdownString, items: string[]) {
 
 function addSymbol(base: MarkdownString, symbol: LookupResult) {
   base.isTrusted = true;
-
-  if ('routine' in symbol) {
-    const routineName = Statement.prettyName(symbol.routine.name);
-    for (let i = 0; i < symbol.signatures.length; i++) {
-      const signature = symbol.signatures[i];
-      const returns = signature.returns.length > 0 ? `: ${signature.returns.length} column${signature.returns.length === 1 ? `` : `s`}` : '';
-
-      base.appendCodeblock(`${routineName}(\n${signature.parms.map((p, pI) => {
-        return `  ${Statement.prettyName(p.PARAMETER_NAME || `parm${pI}`)} => ${prepareParamType(p)}`
-      }).join(',\n')}\n)${returns}`, `sql`);
-
-      if (i < symbol.signatures.length - 1) {
-        base.appendMarkdown(`\n---\n`);
-      }
-    }
-  }
-  else if ('PARAMETER_NAME' in symbol) {
+  if ('PARAMETER_NAME' in symbol) {
     base.appendCodeblock(prepareParamType(symbol) + `\n`, `sql`);
   }
   else if ('COLUMN_NAME' in symbol) {
@@ -149,7 +183,7 @@ function addSymbol(base: MarkdownString, symbol: LookupResult) {
   }
 }
 
-function lookupSymbol(name: string, schema: string|undefined, possibleNames: string[]) {
+function lookupSymbol(name: string, schema: string | undefined, possibleNames: string[]) {
   name = Statement.noQuotes(Statement.delimName(name, true));
   schema = schema ? Statement.noQuotes(Statement.delimName(schema, true)) : undefined
 

src/language/providers/logic/cache.ts

@@ -2,7 +2,7 @@ import Callable, { CallableRoutine, CallableSignature, CallableType } from "../.
 import Schemas, { PageData, SQLType } from "../../../database/schemas";
 import Table from "../../../database/table";
 
-interface RoutineDetail {
+export interface RoutineDetail {
   routine: CallableRoutine;
   signatures: CallableSignature[];
 }

src/language/providers/logic/completion.ts

@@ -34,8 +34,10 @@ export function prepareParamType(param: TableColumn | SQLParm): string {
     baseType += `(${param.NUMERIC_PRECISION}, ${param.NUMERIC_SCALE})`;
   }
 
-  if ([`Y`, `YES`].includes(param.IS_NULLABLE) || ('DEFAULT' in param && param.DEFAULT !== null)) {
-    baseType += ` optional`;
+  const usefulNull = 'COLUMN_NAME' in param || ('ROW_TYPE' in param && param.ROW_TYPE === 'R');
+
+  if (usefulNull && [`Y`, `YES`].includes(param.IS_NULLABLE)) {
+    baseType += ` nullable`;
   };
 
   return baseType;