public void GetDefinitionTimeoutTest()
{
// Given a binding queue that will automatically time out
var languageService = new LanguageService();
Mock <ConnectedBindingQueue> queueMock = new Mock <ConnectedBindingQueue>();
languageService.BindingQueue = queueMock.Object;
ManualResetEvent mre = new ManualResetEvent(true); // Do not block
Mock <QueueItem> itemMock = new Mock <QueueItem>();
itemMock.Setup(i => i.ItemProcessed).Returns(mre);
DefinitionResult timeoutResult = null;
queueMock.Setup(q => q.QueueBindingOperation(
It.IsAny <string>(),
It.IsAny <Func <IBindingContext, CancellationToken, object> >(),
It.IsAny <Func <IBindingContext, object> >(),
It.IsAny <int?>(),
It.IsAny <int?>()))
.Callback <string, Func <IBindingContext, CancellationToken, object>, Func <IBindingContext, object>, int?, int?>(
(key, bindOperation, timeoutOperation, t1, t2) =>
{
timeoutResult = (DefinitionResult)timeoutOperation((IBindingContext)null);
itemMock.Object.Result = timeoutResult;
})
.Returns(() => itemMock.Object);
TextDocumentPosition textDocument = new TextDocumentPosition
{
TextDocument = new TextDocumentIdentifier {
Uri = OwnerUri
},
Position = new Position
{
Line = 0,
Character = 20
}
};
TestConnectionResult connectionResult = TestObjects.InitLiveConnectionInfo();
ScriptFile scriptFile = connectionResult.ScriptFile;
ConnectionInfo connInfo = connectionResult.ConnectionInfo;
scriptFile.Contents = "select * from dbo.func ()";
ScriptParseInfo scriptInfo = new ScriptParseInfo {
IsConnected = true
};
languageService.ScriptParseInfoMap.Add(OwnerUri, scriptInfo);
// When I call the language service
var result = languageService.GetDefinition(textDocument, scriptFile, connInfo);
// Then I expect null locations and an error to be reported
Assert.NotNull(result);
Assert.True(result.IsErrorResult);
// Check timeout message
Assert.Equal(SR.PeekDefinitionTimedoutError, result.Message);
}
/// <summary>
/// Auto-complete completion provider request callback
/// </summary>
/// <param name="textDocumentPosition"></param>
/// <param name="requestContext"></param>
/// <returns></returns>
internal async Task HandleCompletionRequest(TextDocumentPosition textDocumentPosition, RequestContext <CompletionList> requestContext)
{
CompletionList completionList = new CompletionList();
completionList.IsIncomplete = false;
Text text = this.CreateXmlTextFromTextDocumentUri(textDocumentPosition.TextDocument.Uri);
TextPosition textPosition = PositionUtils.CreateTextPosition(text.Content, textDocumentPosition.Position);
XmlCodeCompletionProvider xmlCodeCompletion = this.CreateCodeCompletionProvider(text, textPosition);
XmlCompletionItemCollection xmlCompletionItemCollection = xmlCodeCompletion.RetrieveCompletionItemCollection();
if (xmlCompletionItemCollection != null)
{
foreach (XmlCompletionItem xmlCompletionItem in xmlCompletionItemCollection)
{
completionList.Items.Add(new CompletionItem()
{
Detail = null, //"This is the documentation. Not Implemented",
Documentation = xmlCompletionItem.Documentation,
Kind = CompletionItemKind.Text,
Label = xmlCompletionItem.Text,
});
}
}
await requestContext.SendResult(completionList);
}
public static void GetAutoCompleteTestObjects(
out TextDocumentPosition textDocument,
out ScriptFile scriptFile,
out ConnectionInfo connInfo
)
{
textDocument = new TextDocumentPosition
{
TextDocument = new TextDocumentIdentifier {
Uri = OwnerUri
},
Position = new Position
{
Line = 0,
Character = 0
}
};
connInfo = Common.CreateTestConnectionInfo(null, false);
LanguageService.Instance.ScriptParseInfoMap.Add(textDocument.TextDocument.Uri, new ScriptParseInfo());
scriptFile = new ScriptFile {
ClientFilePath = textDocument.TextDocument.Uri
};
}
public void GetUnsupportedDefinitionErrorTest()
{
ScriptFile scriptFile;
TextDocumentPosition textDocument = new TextDocumentPosition
{
TextDocument = new TextDocumentIdentifier {
Uri = OwnerUri
},
Position = new Position
{
Line = 0,
// test for 'dbo'
Character = 16
}
};
ConnectionInfo connInfo = TestObjects.InitLiveConnectionInfo(out scriptFile);
scriptFile.Contents = "select * from dbo.func ()";
var languageService = new LanguageService();
ScriptParseInfo scriptInfo = new ScriptParseInfo {
IsConnected = true
};
languageService.ScriptParseInfoMap.Add(OwnerUri, scriptInfo);
// When I call the language service
var result = languageService.GetDefinition(textDocument, scriptFile, connInfo);
// Then I expect null locations and an error to be reported
Assert.NotNull(result);
Assert.True(result.IsErrorResult);
}
private ScriptDocumentInfo CreateScriptDocumentInfo()
{
TextDocumentPosition doc = new TextDocumentPosition()
{
TextDocument = new TextDocumentIdentifier
{
Uri = "script file"
},
Position = new Position()
{
Line = 1,
Character = 14
}
};
ScriptFile scriptFile = new ScriptFile()
{
Contents = "Select * from sys.all_objects"
};
ScriptParseInfo scriptParseInfo = new ScriptParseInfo()
{
IsConnected = true
};
ScriptDocumentInfo docInfo = new ScriptDocumentInfo(doc, scriptFile, scriptParseInfo);
return(docInfo);
}
// -- Tooltip information on hover --
public override Hover OnHover(TextDocumentPosition parameters)
{
Uri objUri = new Uri(parameters.uri);
if (objUri.IsFile)
{
// Get compilation info for the current file
string fileName = Path.GetFileName(objUri.LocalPath);
var fileCompiler = typeCobolWorkspace.OpenedFileCompilers[fileName];
// Find the token located below the mouse pointer
var tokensLine = fileCompiler.CompilationResultsForProgram.ProcessedTokensDocumentSnapshot.Lines[parameters.position.line];
var hoveredToken = tokensLine.TokensWithCompilerDirectives.First(token => token.StartIndex <= parameters.position.character && token.StopIndex >= parameters.position.character);
// Return a text describing this token
if (hoveredToken != null)
{
string tokenDescription = hoveredToken.TokenFamily.ToString() + " - " + hoveredToken.TokenType.ToString();
return(new Hover()
{
range = new Range(parameters.position.line, hoveredToken.StartIndex, parameters.position.line, hoveredToken.StopIndex + 1),
contents = new MarkedString[] { new MarkedString()
{
language = "Cobol", value = tokenDescription
} }
});
}
}
return(null);
}
public void MetricsShouldGetSortedGivenUnSortedArray()
{
TextDocumentPosition doc = new TextDocumentPosition()
{
TextDocument = new TextDocumentIdentifier
{
Uri = "script file"
},
Position = new Position()
{
Line = 1,
Character = 14
}
};
ScriptFile scriptFile = new ScriptFile()
{
Contents = "Select * from sys.all_objects"
};
ScriptParseInfo scriptParseInfo = new ScriptParseInfo();
ScriptDocumentInfo docInfo = new ScriptDocumentInfo(doc, scriptFile, scriptParseInfo);
Assert.Equal(docInfo.StartLine, 1);
Assert.Equal(docInfo.ParserLine, 2);
Assert.Equal(docInfo.StartColumn, 44);
Assert.Equal(docInfo.EndColumn, 14);
Assert.Equal(docInfo.ParserColumn, 15);
}
public async void GetDefinitionFromChildrenAndParents()
{
string queryString = "select * from master.sys.objects";
// place the cursor on every token
//cursor on objects
TextDocumentPosition objectDocument = CreateTextDocPositionWithCursor(26, OwnerUri);
//cursor on sys
TextDocumentPosition sysDocument = CreateTextDocPositionWithCursor(22, OwnerUri);
//cursor on master
TextDocumentPosition masterDocument = CreateTextDocPositionWithCursor(17, OwnerUri);
LiveConnectionHelper.TestConnectionResult connectionResult = LiveConnectionHelper.InitLiveConnectionInfo(null);
ScriptFile scriptFile = connectionResult.ScriptFile;
ConnectionInfo connInfo = connectionResult.ConnectionInfo;
connInfo.RemoveAllConnections();
var bindingQueue = new ConnectedBindingQueue();
bindingQueue.AddConnectionContext(connInfo);
scriptFile.Contents = queryString;
var service = new LanguageService();
service.RemoveScriptParseInfo(OwnerUri);
service.BindingQueue = bindingQueue;
await service.UpdateLanguageServiceOnConnection(connectionResult.ConnectionInfo);
Thread.Sleep(2000);
ScriptParseInfo scriptInfo = new ScriptParseInfo {
IsConnected = true
};
service.ParseAndBind(scriptFile, connInfo);
scriptInfo.ConnectionKey = bindingQueue.AddConnectionContext(connInfo);
service.ScriptParseInfoMap.Add(OwnerUri, scriptInfo);
// When I call the language service
var objectResult = service.GetDefinition(objectDocument, scriptFile, connInfo);
var sysResult = service.GetDefinition(sysDocument, scriptFile, connInfo);
var masterResult = service.GetDefinition(masterDocument, scriptFile, connInfo);
// Then I expect the results to be non-null
Assert.NotNull(objectResult);
Assert.NotNull(sysResult);
Assert.NotNull(masterResult);
// And I expect the all results to be the same
Assert.True(CompareLocations(objectResult.Locations, sysResult.Locations));
Assert.True(CompareLocations(objectResult.Locations, masterResult.Locations));
Cleanup(objectResult.Locations);
Cleanup(sysResult.Locations);
Cleanup(masterResult.Locations);
service.ScriptParseInfoMap.Remove(OwnerUri);
connInfo.RemoveAllConnections();
}
/// <summary>
/// Auto-complete completion provider request callback
/// </summary>
/// <param name="textDocumentPosition"></param>
/// <param name="requestContext"></param>
/// <returns></returns>
internal static async Task HandleCompletionRequest(
TextDocumentPosition textDocumentPosition,
RequestContext <CompletionItem[]> requestContext)
{
// check if Intellisense suggestions are enabled
if (!WorkspaceService <SqlToolsSettings> .Instance.CurrentSettings.IsSuggestionsEnabled)
{
await Task.FromResult(true);
}
else
{
// get the current list of completion items and return to client
var scriptFile = LanguageService.WorkspaceServiceInstance.Workspace.GetFile(
textDocumentPosition.TextDocument.Uri);
ConnectionInfo connInfo;
LanguageService.ConnectionServiceInstance.TryFindConnection(
scriptFile.ClientFilePath,
out connInfo);
var completionItems = Instance.GetCompletionItems(
textDocumentPosition, scriptFile, connInfo);
await requestContext.SendResult(completionItems);
}
}
/// <summary>
/// Create new instance
/// </summary>
public ScriptDocumentInfo(TextDocumentPosition textDocumentPosition, ScriptFile scriptFile, ScriptParseInfo scriptParseInfo)
: this(textDocumentPosition, scriptFile)
{
Validate.IsNotNull(nameof(scriptParseInfo), scriptParseInfo);
ScriptParseInfo = scriptParseInfo;
// need to adjust line & column for base-1 parser indices
Token = GetToken(scriptParseInfo, ParserLine, ParserColumn);
}
protected async Task HandleSignatureHelpRequest(
TextDocumentPosition textDocumentPosition,
EditorSession editorSession,
RequestContext <SignatureHelp, object> requestContext)
{
ScriptFile scriptFile =
editorSession.Workspace.GetFile(
textDocumentPosition.Uri);
ParameterSetSignatures parameterSets =
await editorSession.LanguageService.FindParameterSetsInFile(
scriptFile,
textDocumentPosition.Position.Line + 1,
textDocumentPosition.Position.Character + 1);
SignatureInformation[] signatures = null;
int?activeParameter = null;
int?activeSignature = 0;
if (parameterSets != null)
{
signatures =
parameterSets
.Signatures
.Select(s =>
{
return(new SignatureInformation
{
Label = parameterSets.CommandName + " " + s.SignatureText,
Documentation = null,
Parameters =
s.Parameters
.Select(CreateParameterInfo)
.ToArray()
});
})
.ToArray();
}
else
{
signatures = new SignatureInformation[0];
}
await requestContext.SendResult(
new SignatureHelp
{
Signatures = signatures,
ActiveParameter = activeParameter,
ActiveSignature = activeSignature
});
}
/// <summary>
/// Get quick info hover tooltips for the current position
/// </summary>
/// <param name="textDocumentPosition"></param>
/// <param name="scriptFile"></param>
internal Hover GetHoverItem(TextDocumentPosition textDocumentPosition, ScriptFile scriptFile)
{
int startLine = textDocumentPosition.Position.Line;
int startColumn = TextUtilities.PositionOfPrevDelimeter(
scriptFile.Contents,
textDocumentPosition.Position.Line,
textDocumentPosition.Position.Character);
int endColumn = textDocumentPosition.Position.Character;
ScriptParseInfo scriptParseInfo = GetScriptParseInfo(textDocumentPosition.TextDocument.Uri);
if (scriptParseInfo != null && scriptParseInfo.ParseResult != null)
{
if (Monitor.TryEnter(scriptParseInfo.BuildingMetadataLock))
{
try
{
QueueItem queueItem = this.BindingQueue.QueueBindingOperation(
key: scriptParseInfo.ConnectionKey,
bindingTimeout: LanguageService.HoverTimeout,
bindOperation: (bindingContext, cancelToken) =>
{
// get the current quick info text
Babel.CodeObjectQuickInfo quickInfo = Resolver.GetQuickInfo(
scriptParseInfo.ParseResult,
startLine + 1,
endColumn + 1,
bindingContext.MetadataDisplayInfoProvider);
// convert from the parser format to the VS Code wire format
return(AutoCompleteHelper.ConvertQuickInfoToHover(
quickInfo,
startLine,
startColumn,
endColumn));
});
queueItem.ItemProcessed.WaitOne();
return(queueItem.GetResultAsT <Hover>());
}
finally
{
Monitor.Exit(scriptParseInfo.BuildingMetadataLock);
}
}
}
// return null if there isn't a tooltip for the current location
return(null);
}
protected async Task HandleHoverRequest(
TextDocumentPosition textDocumentPosition,
EditorSession editorSession,
RequestContext <Hover, object> requestContext)
{
ScriptFile scriptFile =
editorSession.Workspace.GetFile(
textDocumentPosition.Uri);
SymbolDetails symbolDetails =
await editorSession
.LanguageService
.FindSymbolDetailsAtLocation(
scriptFile,
textDocumentPosition.Position.Line + 1,
textDocumentPosition.Position.Character + 1);
List <MarkedString> symbolInfo = new List <MarkedString>();
Range?symbolRange = null;
if (symbolDetails != null)
{
symbolInfo.Add(
new MarkedString
{
Language = "PowerShell",
Value = symbolDetails.DisplayString
});
if (!string.IsNullOrEmpty(symbolDetails.Documentation))
{
symbolInfo.Add(
new MarkedString
{
Language = "markdown",
Value = symbolDetails.Documentation
});
}
symbolRange = GetRangeFromScriptRegion(symbolDetails.SymbolReference.ScriptRegion);
}
await requestContext.SendResult(
new Hover
{
Contents = symbolInfo.ToArray(),
Range = symbolRange
});
}
/// <summary>
/// Sends an event for specific document using the existing request context
/// </summary>
public static void SendStatusChange <T>(RequestContext <T> requestContext, TextDocumentPosition textDocumentPosition, string status)
{
Task.Factory.StartNew(async() =>
{
if (requestContext != null)
{
string ownerUri = textDocumentPosition != null && textDocumentPosition.TextDocument != null ? textDocumentPosition.TextDocument.Uri : "";
await requestContext.SendEvent(StatusChangedNotification.Type, new StatusChangeParams()
{
OwnerUri = ownerUri,
Status = status
});
}
});
}
private ScriptDocumentInfo(TextDocumentPosition textDocumentPosition, ScriptFile scriptFile)
{
StartLine = textDocumentPosition.Position.Line;
ParserLine = textDocumentPosition.Position.Line + 1;
StartColumn = TextUtilities.PositionOfPrevDelimeter(
scriptFile.Contents,
textDocumentPosition.Position.Line,
textDocumentPosition.Position.Character);
EndColumn = TextUtilities.PositionOfNextDelimeter(
scriptFile.Contents,
textDocumentPosition.Position.Line,
textDocumentPosition.Position.Character);
ParserColumn = textDocumentPosition.Position.Character + 1;
Contents = scriptFile.Contents;
}
public async Task VerifyFunctionSignatureHelpParameter(
TestHelper testHelper,
string ownerUri,
int character,
string expectedFunctionName,
int expectedParameterIndex,
string expectedParameterName)
{
var position = new TextDocumentPosition()
{
TextDocument = new TextDocumentIdentifier()
{
Uri = ownerUri
},
Position = new Position()
{
Line = 0,
Character = character
}
};
var signatureHelp = await testHelper.Driver.SendRequest(SignatureHelpRequest.Type, position);
Assert.NotNull(signatureHelp);
Assert.NotNull(signatureHelp.ActiveSignature);
Assert.True(signatureHelp.ActiveSignature.HasValue);
Assert.NotEmpty(signatureHelp.Signatures);
var activeSignature = signatureHelp.Signatures[signatureHelp.ActiveSignature.Value];
Assert.NotNull(activeSignature);
var label = activeSignature.Label;
Assert.NotNull(label);
Assert.NotEmpty(label);
Assert.True(label.Contains(expectedFunctionName));
Assert.NotNull(signatureHelp.ActiveParameter);
Assert.True(signatureHelp.ActiveParameter.HasValue);
Assert.Equal(expectedParameterIndex, signatureHelp.ActiveParameter.Value);
var parameter = activeSignature.Parameters[signatureHelp.ActiveParameter.Value];
Assert.NotNull(parameter);
Assert.NotNull(parameter.Label);
Assert.NotEmpty(parameter.Label);
Assert.Equal(expectedParameterName, parameter.Label);
}
private TextDocumentPosition CreateTextDocPositionWithCursor(int column, string OwnerUri)
{
TextDocumentPosition textDocPos = new TextDocumentPosition
{
TextDocument = new TextDocumentIdentifier {
Uri = OwnerUri
},
Position = new Position
{
Line = 0,
Character = column
}
};
return(textDocPos);
}
private LiveConnectionHelper.TestConnectionResult GetLiveAutoCompleteTestObjects()
{
var textDocument = new TextDocumentPosition
{
TextDocument = new TextDocumentIdentifier { Uri = Test.Common.Constants.OwnerUri },
Position = new Position
{
Line = 0,
Character = 0
}
};
var result = LiveConnectionHelper.InitLiveConnectionInfo();
result.TextDocumentPosition = textDocument;
return result;
}
public async Task FunctionSignatureCompletionReturnsCorrectFunction()
{
string sqlText = "EXEC sys.fn_isrolemember ";
using (SelfCleaningTempFile tempFile = new SelfCleaningTempFile())
using (TestHelper testHelper = new TestHelper())
{
string ownerUri = tempFile.FilePath;
File.WriteAllText(ownerUri, sqlText);
// Connect
await testHelper.Connect(ownerUri, ConnectionTestUtils.LocalhostConnection);
// Wait for intellisense to be ready
var readyParams = await testHelper.Driver.WaitForEvent(IntelliSenseReadyNotification.Type, 30000);
Assert.NotNull(readyParams);
Assert.Equal(ownerUri, readyParams.OwnerUri);
// Send a function signature help Request
var position = new TextDocumentPosition()
{
TextDocument = new TextDocumentIdentifier()
{
Uri = ownerUri
},
Position = new Position()
{
Line = 0,
Character = sqlText.Length
}
};
var signatureHelp = await testHelper.Driver.SendRequest(SignatureHelpRequest.Type, position);
Assert.NotNull(signatureHelp);
Assert.True(signatureHelp.ActiveSignature.HasValue);
Assert.NotEmpty(signatureHelp.Signatures);
var label = signatureHelp.Signatures[signatureHelp.ActiveSignature.Value].Label;
Assert.NotNull(label);
Assert.NotEmpty(label);
Assert.True(label.Contains("fn_isrolemember"));
await testHelper.Disconnect(ownerUri);
}
}
private static void GetLiveAutoCompleteTestObjects(
out TextDocumentPosition textDocument,
out ScriptFile scriptFile,
out ConnectionInfo connInfo)
{
textDocument = new TextDocumentPosition
{
TextDocument = new TextDocumentIdentifier {
Uri = TestObjects.ScriptUri
},
Position = new Position
{
Line = 0,
Character = 0
}
};
connInfo = TestObjects.InitLiveConnectionInfo(out scriptFile);
}
private TestConnectionResult GetLiveAutoCompleteTestObjects()
{
var textDocument = new TextDocumentPosition
{
TextDocument = new TextDocumentIdentifier {
Uri = TestObjects.ScriptUri
},
Position = new Position
{
Line = 0,
Character = 0
}
};
var result = TestObjects.InitLiveConnectionInfo();
result.TextDocumentPosition = textDocument;
return(result);
}
private static async Task HandleHoverRequest(
TextDocumentPosition textDocumentPosition,
RequestContext <Hover> requestContext)
{
// check if Quick Info hover tooltips are enabled
if (WorkspaceService <SqlToolsSettings> .Instance.CurrentSettings.IsQuickInfoEnabled)
{
var scriptFile = WorkspaceService <SqlToolsSettings> .Instance.Workspace.GetFile(
textDocumentPosition.TextDocument.Uri);
var hover = LanguageService.Instance.GetHoverItem(textDocumentPosition, scriptFile);
if (hover != null)
{
await requestContext.SendResult(hover);
}
}
await requestContext.SendResult(new Hover());
}
/// <summary>
/// Request a list of completion items for a position in a block of text
/// </summary>
public async Task <CompletionItem[]> RequestCompletion(string ownerUri, string text, int line, int character)
{
// Write the text to a backing file
lock (fileLock)
{
System.IO.File.WriteAllText(ownerUri, text);
}
var completionParams = new TextDocumentPosition();
completionParams.TextDocument = new TextDocumentIdentifier();
completionParams.TextDocument.Uri = ownerUri;
completionParams.Position = new Position();
completionParams.Position.Line = line;
completionParams.Position.Character = character;
var result = await Driver.SendRequest(CompletionRequest.Type, completionParams);
return(result);
}
public async Task FunctionSignatureCompletionReturnsEmptySignatureHelpObjectWhenThereAreNoMatches()
{
string sqlText = "EXEC sys.fn_not_a_real_function ";
using (SelfCleaningTempFile tempFile = new SelfCleaningTempFile())
using (TestHelper testHelper = new TestHelper())
{
string ownerUri = tempFile.FilePath;
File.WriteAllText(ownerUri, sqlText);
// Connect
await testHelper.Connect(ownerUri, ConnectionTestUtils.LocalhostConnection);
// Wait for intellisense to be ready
var readyParams = await testHelper.Driver.WaitForEvent(IntelliSenseReadyNotification.Type, 30000);
Assert.NotNull(readyParams);
Assert.Equal(ownerUri, readyParams.OwnerUri);
// Send a function signature help Request
var position = new TextDocumentPosition()
{
TextDocument = new TextDocumentIdentifier()
{
Uri = ownerUri
},
Position = new Position()
{
Line = 0,
Character = sqlText.Length
}
};
var signatureHelp = await testHelper.Driver.SendRequest(SignatureHelpRequest.Type, position);
Assert.NotNull(signatureHelp);
Assert.False(signatureHelp.ActiveSignature.HasValue);
Assert.Null(signatureHelp.Signatures);
await testHelper.Disconnect(ownerUri);
}
}
// ----------------------------------------------------------------------------------------------- //
public override Hover OnHover(TextDocumentPosition parameters)
{
AnalyticsWrapper.Telemetry.TrackEvent("[LSP] Hover", EventType.Completion);
var fileCompiler = GetFileCompilerFromStringUri(parameters.uri);
if (fileCompiler == null)
{
return(null);
}
// Find the token located below the mouse pointer
var tokensLine =
fileCompiler.CompilationResultsForProgram.ProcessedTokensDocumentSnapshot.Lines[
parameters.position.line];
var hoveredToken =
tokensLine.TokensWithCompilerDirectives.First(
token =>
token.StartIndex <= parameters.position.character &&
token.StopIndex >= parameters.position.character);
// Return a text describing this token
if (hoveredToken != null)
{
string tokenDescription = hoveredToken.TokenFamily.ToString() + " - " +
hoveredToken.TokenType.ToString();
return(new Hover()
{
range =
new Range(parameters.position.line, hoveredToken.StartIndex, parameters.position.line,
hoveredToken.StopIndex + 1),
contents =
new MarkedString[] { new MarkedString()
{
language = "Cobol", value = tokenDescription
} }
});
}
return(null);
}
/// <summary>
/// Request definition( peek definition/go to definition) for a sql object in a sql string
/// </summary>
public async Task <Location[]> RequestDefinition(string ownerUri, string text, int line, int character)
{
// Write the text to a backing file
lock (fileLock)
{
System.IO.File.WriteAllText(ownerUri, text);
}
var definitionParams = new TextDocumentPosition();
definitionParams.TextDocument = new TextDocumentIdentifier();
definitionParams.TextDocument.Uri = ownerUri;
definitionParams.Position = new Position();
definitionParams.Position.Line = line;
definitionParams.Position.Character = character;
// Send definition request
var result = await Driver.SendRequest(DefinitionRequest.Type, definitionParams);
return(result);
}
protected async Task HandleDefinitionRequest(
TextDocumentPosition textDocumentPosition,
EditorSession editorSession,
RequestContext <Location[], object> requestContext)
{
ScriptFile scriptFile =
editorSession.Workspace.GetFile(
textDocumentPosition.Uri);
SymbolReference foundSymbol =
editorSession.LanguageService.FindSymbolAtLocation(
scriptFile,
textDocumentPosition.Position.Line + 1,
textDocumentPosition.Position.Character + 1);
List <Location> definitionLocations = new List <Location>();
GetDefinitionResult definition = null;
if (foundSymbol != null)
{
definition =
await editorSession.LanguageService.GetDefinitionOfSymbol(
scriptFile,
foundSymbol,
editorSession.Workspace);
if (definition != null)
{
definitionLocations.Add(
new Location
{
Uri = new Uri(definition.FoundDefinition.FilePath).AbsoluteUri,
Range = GetRangeFromScriptRegion(definition.FoundDefinition.ScriptRegion)
});
}
}
await requestContext.SendResult(definitionLocations.ToArray());
}
public async Task GetSignatureHelpReturnsNotNullIfParseInfoInitialized()
{
// When we make a connection to a live database
Hosting.ServiceHost.SendEventIgnoreExceptions = true;
var result = LiveConnectionHelper.InitLiveConnectionInfo();
// And we place the cursor after a function that should prompt for signature help
string queryWithFunction = "EXEC sys.fn_isrolemember ";
result.ScriptFile.Contents = queryWithFunction;
TextDocumentPosition textDocument = new TextDocumentPosition
{
TextDocument = new TextDocumentIdentifier
{
Uri = result.ScriptFile.ClientFilePath
},
Position = new Position
{
Line = 0,
Character = queryWithFunction.Length
}
};
// If the SQL has already been parsed
var service = LanguageService.Instance;
await service.UpdateLanguageServiceOnConnection(result.ConnectionInfo);
Thread.Sleep(2000);
// We should get back a non-null ScriptParseInfo
ScriptParseInfo parseInfo = service.GetScriptParseInfo(result.ScriptFile.ClientFilePath);
Assert.NotNull(parseInfo);
// And we should get back a non-null SignatureHelp
SignatureHelp signatureHelp = service.GetSignatureHelp(textDocument, result.ScriptFile);
Assert.NotNull(signatureHelp);
}
protected async Task HandleDocumentHighlightRequest(
TextDocumentPosition textDocumentPosition,
EditorSession editorSession,
RequestContext <DocumentHighlight[], object> requestContext)
{
ScriptFile scriptFile =
editorSession.Workspace.GetFile(
textDocumentPosition.Uri);
FindOccurrencesResult occurrencesResult =
editorSession.LanguageService.FindOccurrencesInFile(
scriptFile,
textDocumentPosition.Position.Line + 1,
textDocumentPosition.Position.Character + 1);
DocumentHighlight[] documentHighlights = null;
if (occurrencesResult != null)
{
documentHighlights =
occurrencesResult
.FoundOccurrences
.Select(o =>
{
return(new DocumentHighlight
{
Kind = DocumentHighlightKind.Write, // TODO: Which symbol types are writable?
Range = GetRangeFromScriptRegion(o.ScriptRegion)
});
})
.ToArray();
}
else
{
documentHighlights = new DocumentHighlight[0];
}
await requestContext.SendResult(documentHighlights);
}
protected async Task HandleCompletionRequest(
TextDocumentPosition textDocumentPosition,
RequestContext <CompletionItem[]> requestContext)
{
int cursorLine = textDocumentPosition.Position.Line + 1;
int cursorColumn = textDocumentPosition.Position.Character + 1;
ScriptFile scriptFile =
editorSession.Workspace.GetFile(
textDocumentPosition.Uri);
CompletionResults completionResults =
await editorSession.LanguageService.GetCompletionsInFile(
scriptFile,
cursorLine,
cursorColumn);
CompletionItem[] completionItems = null;
if (completionResults != null)
{
int sortIndex = 1;
completionItems =
completionResults
.Completions
.Select(
c => CreateCompletionItem(
c,
completionResults.ReplacedRange,
sortIndex++))
.ToArray();
}
else
{
completionItems = new CompletionItem[0];
}
await requestContext.SendResult(completionItems);
}
