Merge pull request #266 from codefori/feature/rename_provider

Feature/rename_provider

extension/client/src/schemas/default.js

@@ -5,7 +5,6 @@ module.exports = {
   NoSELECTAll: true,
   UppercaseConstants: true,
   IncorrectVariableCase: true,
-  StringLiteralDupe: true,
   NoSQLJoins: true,
   PrettyComments: true,
   NoGlobalSubroutines: true,

extension/server/src/providers/completionItem.ts

@@ -106,7 +106,7 @@ export default async function completionItemProvider(handler: CompletionParams):
 					const expandScope = (localCache: Cache) => {
 						for (const subItem of localCache.parameters) {
 							const item = CompletionItem.create(`${subItem.name}`);
-							item.kind = CompletionItemKind.Variable;
+							item.kind = CompletionItemKind.TypeParameter;
 							item.insertText = subItem.name;
 							item.detail = [`parameter`, ...subItem.keywords].join(` `);
 							item.documentation = subItem.description;
@@ -212,8 +212,24 @@ export default async function completionItemProvider(handler: CompletionParams):
 
 					expandScope(doc);
 
-					if (currentProcedure && currentProcedure.scope) {
-						expandScope(currentProcedure.scope);
+					if (currentProcedure) {
+						// If we have the entire scope, perfect
+						if (currentProcedure.scope) {
+							expandScope(currentProcedure.scope);
+						}
+
+						// subItems get moved to parameters when the procedure is ended correctly.
+						// So if the user is in the middle of a statement, then they still exist in the subItems
+						else if (currentProcedure.subItems.length > 0) {
+							for (const subItem of currentProcedure.subItems) {
+								const item = CompletionItem.create(`${subItem.name}`);
+								item.kind = CompletionItemKind.TypeParameter;
+								item.insertText = subItem.name;
+								item.detail = [`parameter`, ...subItem.keywords].join(` `);
+								item.documentation = subItem.description;
+								items.push(item);
+							}
+						}
 					}
 
 					if (isFree) {

extension/server/src/providers/definition.ts

@@ -1,6 +1,8 @@
 import { DefinitionParams, Location, Definition, Range } from 'vscode-languageserver';
 import { documents, getWordRangeAtPosition, parser } from '.';
 import Parser from '../../../../language/parser';
+import Cache from '../../../../language/models/cache';
+import Declaration from '../../../../language/models/declaration';
 
 export default async function definitionProvider(handler: DefinitionParams): Promise<Definition|null> {
 	const currentPath = handler.textDocument.uri;
@@ -20,9 +22,28 @@ export default async function definitionProvider(handler: DefinitionParams): Pro
 				}
 
 			} else {
+				let def: Declaration|undefined;
+
+				// First, we try and get the reference by offset
+				def = Cache.referenceByOffset(doc, document.offsetAt(handler.position));
+
+				if (def) {
+					return Location.create(
+						def.position.path,
+						Range.create(
+							def.position.line,
+							0,
+							def.position.line,
+							0
+						)
+					);
+				}
+
+				// If we can't find the def by offset, we do a basic word lookup
+
 				const word = getWordRangeAtPosition(document, handler.position);
 				if (word) {
-					const def = doc.findDefinition(lineNumber, word);
+					def = doc.findDefinition(lineNumber, word);
 
 					if (def) {
 						return Location.create(

extension/server/src/providers/linter/codeActions.ts

@@ -15,7 +15,10 @@ export default async function codeActionsProvider(params: CodeActionParams): Pro
 			if (docs) {
 				const detail = await refreshLinterDiagnostics(document, docs, false);
 				if (detail) {
-					const fixErrors = detail.errors.filter(error => range.start.line === document.positionAt(error.offset.position!).line );
+					const fixErrors = detail.errors.filter(error => 
+						range.start.line >= document.positionAt(error.offset.position!).line &&
+						range.end.line <= document.positionAt(error.offset.end!).line
+					);
 
 					if (fixErrors.length > 0) {
 						return getActions(document, fixErrors);

extension/server/src/providers/linter/index.ts

@@ -182,6 +182,8 @@ export async function getLintOptions(workingUri: string) {
 	return result;
 }
 
+const hintDiagnositcs: (keyof Rules)[] = [`SQLRunner`, `StringLiteralDupe`]
+
 export async function refreshLinterDiagnostics(document: TextDocument, docs: Cache, updateDiagnostics = true) {
 	const isFree = (document.getText(Range.create(0, 0, 0, 6)).toUpperCase() === `**FREE`);
 	if (isFree) {
@@ -201,6 +203,11 @@ export async function refreshLinterDiagnostics(document: TextDocument, docs: Cac
 			availableIncludes = headers.map(header => header.relative);
 		}
 
+		// Turn on for SQLRunner suggestions
+		// options.SQLRunner = true;
+
+		options.StringLiteralDupe = true;
+
 		try {
 			detail = Linter.getErrors({
 				uri: document.uri,
@@ -236,7 +243,7 @@ export async function refreshLinterDiagnostics(document: TextDocument, docs: Cac
 				const diagnostic = Diagnostic.create(
 					range,
 					Linter.getErrorText(error.type),
-					DiagnosticSeverity.Warning
+					error.type && hintDiagnositcs.includes(error.type) ? DiagnosticSeverity.Hint : DiagnosticSeverity.Warning
 				);
 
 				generalDiags.push(diagnostic);
@@ -349,7 +356,6 @@ export function getActions(document: TextDocument, errors: IssueRange[]) {
 
 			case `SQLHostVarCheck`:
 			case `CopybookDirective`:
-			case `StringLiteralDupe`:
 			case `NoGlobalSubroutines`:
 				if (error.newValue) {
 					action = CodeAction.create(`Switch to '${error.newValue}'`, CodeActionKind.QuickFix);
@@ -364,6 +370,20 @@ export function getActions(document: TextDocument, errors: IssueRange[]) {
 				}
 				break;
 
+			case `StringLiteralDupe`:
+				if (error.newValue) {
+					action = CodeAction.create(`Switch to '${error.newValue}'`, CodeActionKind.RefactorExtract);
+					action.edit = {
+						changes: {
+							[document.uri]: [
+								TextEdit.replace(errorRange, error.newValue)
+							]
+						},
+					}
+					actions.push(action);
+				}
+				break;
+
 			case `IncludeMustBeRelative`:
 				if (error.newValue) {
 					action = CodeAction.create(`Correct path to ${error.newValue}`, CodeActionKind.QuickFix);
@@ -391,6 +411,22 @@ export function getActions(document: TextDocument, errors: IssueRange[]) {
 					actions.push(action);
 				}
 				break;
+
+			case `SQLRunner`:
+				if (error.newValue) {
+					action = CodeAction.create(`Run statement in Db2 for i`, CodeActionKind.Empty);
+					action.command = {
+						title: `Run statement`,
+						command: `vscode-db2i.runEditorStatement`,
+						arguments: [{
+							content: error.newValue,
+							qualifier: `statement`,
+							open: true,
+							viewColumn: -2
+						}]
+					};
+					actions.push(action);
+				}
 		}
 	});
 

extension/server/src/providers/reference.ts

@@ -5,25 +5,23 @@ import { calculateOffset } from './linter';
 
 import * as Project from "./project";
 import { findAllLocalReferences } from './project/references';
+import Cache from '../../../../language/models/cache';
 
 export async function referenceProvider(params: ReferenceParams): Promise<Location[]|undefined> {
 	const uri = params.textDocument.uri;
 	const position = params.position;
 	const document = documents.get(uri);
 
 	if (document) {
-		const isFree = (document.getText(Range.create(0, 0, 0, 6)).toUpperCase() === `**FREE`);
-
-		let word = getWordRangeAtPosition(document, position)?.trim();
-
-		if (word) {
-      if (word.endsWith(`;`)) {
-        const pieces = word.split(`;`);
-        word = pieces[0];
-      }
-
+		const uri = params.textDocument.uri;
+		const currentPos = params.position;
+		const document = documents.get(uri);
+
+		if (document) {
+			const isFree = (document.getText(Range.create(0, 0, 0, 6)).toUpperCase() === `**FREE`);
+
 			const doc = await parser.getDocs(uri, document.getText());
-
+	
 			if (doc) {
 				if (isFree) {
 					Linter.getErrors(
@@ -37,8 +35,8 @@ export async function referenceProvider(params: ReferenceParams): Promise<Locati
 						doc
 					);
 				}
-
-				const def = doc.findDefinition(position.line, word);
+	
+				const def = Cache.referenceByOffset(doc, document.offsetAt(currentPos));
 
 				if (def) {
 					if (Project.isEnabled) {

extension/server/src/providers/rename.ts

@@ -0,0 +1,97 @@
+
+import { documents, getWordRangeAtPosition, parser } from '.';
+import { PrepareRenameParams, Range, RenameParams, TextEdit, WorkspaceEdit } from "vscode-languageserver";
+import Linter from '../../../../language/linter';
+import Cache from '../../../../language/models/cache';
+import Declaration from '../../../../language/models/declaration';
+
+export async function renamePrepareProvider(params: PrepareRenameParams): Promise<Range | undefined> {
+  const uri = params.textDocument.uri;
+  const currentPos = params.position;
+  const document = documents.get(uri);
+
+  if (document) {
+    const isFree = (document.getText(Range.create(0, 0, 0, 6)).toUpperCase() === `**FREE`);
+
+    const doc = await parser.getDocs(uri, document.getText());
+
+    if (doc) {
+      if (isFree) {
+        Linter.getErrors(
+          {
+            uri,
+            content: document.getText()
+          },
+          {
+            CollectReferences: true
+          },
+          doc
+        );
+      }
+
+      const def = Cache.referenceByOffset(doc, document.offsetAt(currentPos));
+
+      if (def) {
+        const currentSelectedRef = def?.references.find(r => document.positionAt(r.offset.position).line === currentPos.line);
+
+        if (currentSelectedRef) {
+          return Range.create(
+            document.positionAt(currentSelectedRef.offset.position),
+            document.positionAt(currentSelectedRef.offset.end)
+          )
+        }
+      }
+    }
+  }
+
+  return;
+}
+
+export async function renameRequestProvider(params: RenameParams): Promise<WorkspaceEdit | undefined> {
+  const uri = params.textDocument.uri;
+  const currentPos = params.position;
+  const document = documents.get(uri);
+
+  if (document) {
+    const isFree = (document.getText(Range.create(0, 0, 0, 6)).toUpperCase() === `**FREE`);
+
+    const doc = await parser.getDocs(uri, document.getText());
+
+    if (doc) {
+      if (isFree) {
+        Linter.getErrors(
+          {
+            uri,
+            content: document.getText()
+          },
+          {
+            CollectReferences: true
+          },
+          doc
+        );
+      }
+
+      const def = Cache.referenceByOffset(doc, document.offsetAt(currentPos));
+
+      if (def) {
+        const edits: TextEdit[] = def.references.map(ref => ({
+          newText: params.newName,
+          range: Range.create(
+            document.positionAt(ref.offset.position),
+            document.positionAt(ref.offset.end)
+          )
+        }));
+
+        const workspaceEdit: WorkspaceEdit = {
+          changes: {
+            [document.uri]: edits
+          }
+        }
+
+        return workspaceEdit;
+      }
+    }
+  }
+
+  return;
+}

extension/server/src/server.ts

@@ -29,6 +29,7 @@ import implementationProvider from './providers/implementation';
 import { dspffdToRecordFormats, parseMemberUri } from './data';
 import path = require('path');
 import { existsSync } from 'fs';
+import { renamePrepareProvider, renameRequestProvider } from './providers/rename';
 
 let hasConfigurationCapability = false;
 let hasWorkspaceFolderCapability = false;
@@ -72,6 +73,7 @@ connection.onInitialize((params: InitializeParams) => {
 		result.capabilities.hoverProvider = true;
 		result.capabilities.referencesProvider = true;
 		result.capabilities.implementationProvider = true;
+		result.capabilities.renameProvider = {prepareProvider: true};
 	}
 
 	if (linterEnabled) {
@@ -290,6 +292,8 @@ if (languageToolsEnabled) {
 	connection.onCompletion(completionItemProvider);
 	connection.onHover(hoverProvider);
 	connection.onReferences(referenceProvider);
+	connection.onPrepareRename(renamePrepareProvider);
+	connection.onRenameRequest(renameRequestProvider);
 
 	// project specific
 	connection.onWorkspaceSymbol(workspaceSymbolProvider);