Merge pull request #448 from codefori/feature/function_suggestions

Support for signature information, built-in function improvements

Author: worksofliam

extension/server/src/providers/apis/bif.ts

@@ -1,14 +1,15 @@
 import path = require('path');
-import { CompletionItem, CompletionItemKind, CompletionParams, InsertTextFormat, Position, Range } from 'vscode-languageserver';
+import { CompletionItem, CompletionItemKind, CompletionParams, InsertTextFormat, InsertTextMode, Position, Range, TextEdit } from 'vscode-languageserver';
 import { documents, getWordRangeAtPosition, parser, prettyKeywords } from '.';
-import Cache from '../../../../language/models/cache';
+import Cache, { RpgleType, RpgleVariableType } from '../../../../language/models/cache';
 import Declaration from '../../../../language/models/declaration';
 import * as ileExports from './apis';
 import skipRules from './linter/skipRules';
 import * as Project from "./project";
 import { getInterfaces } from './project/exportInterfaces';
 import Parser from '../../../../language/parser';
 import { Token } from '../../../../language/types';
+import { getBuiltIn, getBuiltIns, getBuiltInsForType } from './apis/bif';
 
 const completionKind = {
 	function: CompletionItemKind.Interface,
@@ -17,6 +18,19 @@ const completionKind = {
 
 const eol = `\n`;
 
+const builtInFunctionCompletionItems: CompletionItem[] = getBuiltIns().map(builtIn => {
+	const item = CompletionItem.create(builtIn.name);
+	item.filterText = builtIn.name.substring(1);
+	item.kind = CompletionItemKind.Function;
+	item.detail = builtIn.returnType || `void`;
+	item.documentation = `Built-in function`;
+	item.insertText = builtIn.name + `(\${1})`;
+	item.insertTextFormat = InsertTextFormat.Snippet;
+	item.command = {command: `editor.action.triggerParameterHints`, title: `Trigger Parameter Hints`};
+	item.sortText = item.filterText;
+	return item;
+});
+
 export default async function completionItemProvider(handler: CompletionParams): Promise<CompletionItem[]> {
 	const items: CompletionItem[] = [];
 	const lineNumber = handler.position.line;
@@ -30,38 +44,35 @@ export default async function completionItemProvider(handler: CompletionParams):
 		if (doc) {
 			const isFree = (document.getText(Range.create(0, 0, 0, 6)).toUpperCase() === `**FREE`);
 
-			// If they're typing inside of a procedure, let's get the stuff from there too
-			const currentProcedure = doc.procedures.find((proc, index) =>
-				proc.range.start && proc.range.end &&
-				lineNumber >= proc.range.start &&
-				(lineNumber <= proc.range.end + 1 || index === doc.procedures.length - 1) &&
-				currentPath === proc.position.path
-			);
-
 			const currentLine = document.getText(Range.create(
 				handler.position.line,
 				0,
 				handler.position.line,
 				200
 			));
 
-			// This means we're just looking for subfields in the struct
 			if (trigger === `.`) {
+
+				//================================================
+				// Logic for showing subfields (subitems) on symbols
+				//================================================
+
 				const cursorIndex = handler.position.character;
 				let tokens = Parser.lineTokens(isFree ? currentLine : currentLine.length >= 7 ? ``.padEnd(7) + currentLine.substring(7) : ``, 0, 0, true);
 
 				if (tokens.length > 0) {
 
 					// We need to find the innermost block we are part of
-					tokens = Parser.fromBlocksGetTokens(tokens, cursorIndex);
+					tokens = Parser.fromBlocksGetTokens(tokens, cursorIndex).block;
 
 					// Remove any tokens after the cursor
 					tokens = tokens.filter(token => token.range.end <= cursorIndex);
 
 					// Get the possible variable we're referring to
-					let tokenIndex = Parser.getReference(tokens, cursorIndex);
+					const referenceStart = Parser.getReference(tokens, cursorIndex);
+					let tokenIndex = referenceStart;
 
-					let currentDef: Declaration | undefined;
+					let currentDef: Declaration|undefined;
 
 					for (tokenIndex; tokenIndex < tokens.length; tokenIndex++) {
 						if (tokens[tokenIndex] === undefined || [`block`, `dot`, `newline`].includes(tokens[tokenIndex].type)) {
@@ -73,39 +84,91 @@ export default async function completionItemProvider(handler: CompletionParams):
 						if (!word) break;
 
 						if (currentDef) {
-							if (currentDef.subItems && currentDef.subItems.length > 0) {
+							if (currentDef.type !== `procedure` && currentDef.subItems && currentDef.subItems.length > 0) {
 								currentDef = currentDef.subItems.find(subItem => subItem.name.toUpperCase() === word);
 							}
 
 						} else {
-							currentDef = [
-								// First we search the local procedure
-								currentProcedure && currentProcedure.scope ? currentProcedure.scope.parameters.find(parm => parm.name.toUpperCase() === word && parm.subItems.length > 0) : undefined,
-								currentProcedure && currentProcedure.scope ? currentProcedure.scope.structs.find(struct => struct.name.toUpperCase() === word && struct.keyword[`QUALIFIED`]) : undefined,
-								currentProcedure && currentProcedure.scope ? currentProcedure.scope.constants.find(struct => struct.subItems.length > 0 && struct.name.toUpperCase() === word) : undefined,
-	
-								// Then we search the globals
-								doc.structs.find(struct => struct.name.toUpperCase() === word && struct.keyword[`QUALIFIED`]),
-								doc.constants.find(constants => constants.subItems.length > 0 && constants.name.toUpperCase() === word)
-							].find(x => x); // find the first non-undefined item
-
-							if (currentDef && currentDef.subItems.length > 0) {
+							currentDef = doc.findDefinition(lineNumber, word);
+
+							if (currentDef) {
+								if (currentDef.type === `struct` && currentDef.keyword[`QUALIFIED`] === undefined) {
+									currentDef = undefined;
+								}
+
 								// All good!
 							} else {
 								currentDef = undefined;
 							}
 						}
 					}
 
-					if (currentDef && currentDef.subItems.length > 0) {
-						items.push(...currentDef.subItems.map(subItem => {
-							const item = CompletionItem.create(subItem.name);
-							item.kind = CompletionItemKind.Property;
-							item.insertText = subItem.name;
-							item.detail = prettyKeywords(subItem.keyword);
-							item.documentation = subItem.description + ` (${currentDef.name})`;
-							return item;
-						}));
+					let onType: RpgleType|undefined;
+					let onArray = false;
+
+					if (currentDef) {
+						if (currentDef.subItems.length > 0) {
+							items.push(...currentDef.subItems.map(subItem => {
+								const item = CompletionItem.create(subItem.name);
+								item.kind = CompletionItemKind.Property;
+								item.insertText = subItem.name;
+								item.detail = prettyKeywords(subItem.keyword);
+								item.documentation = subItem.description + ` (${currentDef.name})`;
+								return item;
+							}));
+						}
+
+						const typeDetail = doc.resolveType(currentDef);
+						if (typeDetail.type) {
+							onType = typeDetail.type.name;
+							onArray = typeDetail.type.isArray;
+						}
+					} else if (tokens[referenceStart].type === `builtin` && tokens[referenceStart].value) {
+						const builtIn = getBuiltIn(tokens[referenceStart].value);
+						if (builtIn) {
+							onType = builtIn.returnType;
+						}
+					}
+
+					//================================================
+					// How about showing applicable built-in functions for a given type?
+					//================================================
+
+					if (onType) {
+						const usableFunctions = getBuiltInsForType(onType, onArray);
+						if (usableFunctions.length > 0) {
+							const changeRange = Range.create(
+								handler.position.line,
+								tokens[referenceStart].range.start,
+								handler.position.line,
+								tokens[tokens.length-1].range.end
+							);
+
+							const refValue = currentLine.substring(tokens[referenceStart].range.start, tokens[tokens.length-1].range.start);
+
+							for (let func of usableFunctions) {
+								let builtInFunction = CompletionItem.create(func.name.substring(1));
+								builtInFunction.kind = CompletionItemKind.Function;
+
+								const requiredParms = func.parameters.filter(p => !p.optional);
+
+								builtInFunction.additionalTextEdits = [TextEdit.del(changeRange)];
+								builtInFunction.insertText = `${func.name}(` + requiredParms.map((p, i) => {
+									if (p.base) {
+										return refValue
+									} else {
+										return `\${${i+1}:${p.name}}`
+									}
+								}).join(`:`) + `)`;
+								builtInFunction.insertTextFormat = InsertTextFormat.Snippet;
+
+								// To trigger the signature information
+								builtInFunction.command = {command: `editor.action.triggerParameterHints`, title: `Trigger Parameter Hints`};
+
+								builtInFunction.detail = `Built-in function`;
+								items.push(builtInFunction);
+							}
+						}
 					}
 				}
 			} else {
@@ -128,6 +191,11 @@ export default async function completionItemProvider(handler: CompletionParams):
 					items.push(...skipRules);
 
 				} else {
+
+					//================================================
+					// Content assist on existing symbols
+					//================================================
+
 					const expandScope = (localCache: Cache) => {
 						for (const subItem of localCache.parameters) {
 							const item = CompletionItem.create(subItem.name);
@@ -149,6 +217,10 @@ export default async function completionItemProvider(handler: CompletionParams):
 							item.insertText = `${procedure.name}(${procedure.subItems.map((parm, index) => `\${${index + 1}:${parm.name}}`).join(`:`)})`;
 							item.detail = prettyKeywords(procedure.keyword);
 							item.documentation = procedure.description;
+
+							if (procedure.subItems.length > 0) {
+								item.command = { command: `editor.action.triggerParameterHints`, title: `Trigger Parameter Hints` };
+							}
 							items.push(item);
 						}
 
@@ -241,6 +313,14 @@ export default async function completionItemProvider(handler: CompletionParams):
 
 					expandScope(doc);
 
+					// If they're typing inside of a procedure, let's get the stuff from there too
+					const currentProcedure = doc.procedures.find((proc, index) =>
+						proc.range.start && proc.range.end &&
+						lineNumber >= proc.range.start &&
+						(lineNumber <= proc.range.end + 1 || index === doc.procedures.length - 1) &&
+						currentPath === proc.position.path
+					);
+
 					if (currentProcedure) {
 						// If we have the entire scope, perfect
 						if (currentProcedure.scope) {
@@ -261,6 +341,10 @@ export default async function completionItemProvider(handler: CompletionParams):
 						}
 					}
 
+					//================================================
+					// Auto-import logic 
+					//================================================
+
 					if (isFree) {
 						const isInclude = currentPath.toLowerCase().endsWith(`.rpgleinc`);
 						const insertAt = doc.getDefinitionBlockEnd(document.uri) + 1;
@@ -317,6 +401,12 @@ export default async function completionItemProvider(handler: CompletionParams):
 							items.push(item);
 						})
 					}
+
+					//================================================
+					// Showing the available built-in functions
+					//================================================
+
+					items.push(...builtInFunctionCompletionItems);
 				}
 			}
 		}

extension/server/src/providers/completionItem.ts

@@ -1,5 +1,5 @@
 import { Hover, HoverParams, MarkupKind, Range } from 'vscode-languageserver';
-import { documents, getWordRangeAtPosition, parser, prettyKeywords } from '.';
+import { documents, getReturnValue, getWordRangeAtPosition, parser, prettyKeywords } from '.';
 import Parser from "../../../../language/parser";
 import { URI } from 'vscode-uri';
 import { Keywords } from '../../../../language/parserTypes';
@@ -30,14 +30,7 @@ export default async function hoverProvider(params: HoverParams): Promise<Hover
 					}
 
 					let markdown = ``;
-					let returnValue = `void`
-
-					let returnKeywords: Keywords = {
-						...symbol.keyword,
-					};
-					delete returnKeywords[`EXTPROC`];
-
-					if (Object.keys(returnKeywords).length > 0) returnValue = prettyKeywords(returnKeywords);
+					const returnValue = getReturnValue(symbol);
 
 					const returnTag = symbol.tags.find(tag => tag.tag === `return`);
 					const deprecatedTag = symbol.tags.find(tag => tag.tag === `deprecated`);

extension/server/src/providers/hover.ts

@@ -10,6 +10,7 @@ import {
 	TextDocument
 } from 'vscode-languageserver-textdocument';
 import Parser from '../../../../language/parser';
+import Declaration from '../../../../language/models/declaration';
 
 type Keywords = { [key: string]: string | boolean };
 
@@ -60,4 +61,16 @@ export function prettyKeywords(keywords: Keywords, filter: boolean = false): str
 			return undefined;
 		}
 	}).filter(k => k).join(` `);
+}
+
+export function getReturnValue(symbol: Declaration): string {
+  let returnValue = `void`
+
+  let returnKeywords: Keywords = {
+    ...symbol.keyword,
+  };
+  delete returnKeywords[`EXTPROC`];
+
+  if (Object.keys(returnKeywords).length > 0) returnValue = prettyKeywords(returnKeywords);
+  return returnValue;
 }