public ConsoleViewModel()
{
_completionOpen = DateTime.Now.AddDays(-1);
_settings = new JsonSerializerSettings();
XmlTextReader reader = new XmlTextReader(new System.IO.StringReader(Resources.Highlight));
reader.Read();
HighlightManager = HighlightingLoader.Load(reader, HighlightingManager.Instance);
SubscribeTextAreaCommand = new DelegateCommand <TextEditor>((edit) =>
{
var it = new InteractiveContainerHolder(edit);
_edit = edit;
//_manager.SetDocument(it);
_compProvider = new CompletionProvider(_service, edit.Document);
_compProvider.SetDocument(it);
edit.TextArea.TextEntering += TextArea_TextEntering;
edit.TextArea.TextEntered += TextArea_TextEntered;
edit.TextArea.Focus();
_area = edit.TextArea;
edit.TextArea.ReadOnlySectionProvider = new ReadOnlySectionProvider(_area);
_service.Executor.ExecuteScript("Console.WriteLine(\"UAB Medicine VMS Console v.1.0\")");
});
StartScriptCs();
}
protected override void OnCompilationWorkspaceAvailable()
{
Func <string, Microsoft.CodeAnalysis.Text.SourceText> getSourceTextByModelId = modelId
=> CodeCells
.Values
.Select(s => s.Editor)
.OfType <CodeCellEditorView> ()
.FirstOrDefault(e => !e.IsDisposed && e.GetMonacoModelId() == modelId)
?.SourceTextContent;
completionProvider?.Dispose();
signatureHelpProvider?.Dispose();
hoverProvider?.Dispose();
completionProvider = new CompletionProvider(
ClientSession.CompilationWorkspace,
webView.Document.Context,
getSourceTextByModelId);
signatureHelpProvider = new SignatureHelpProvider(
ClientSession.CompilationWorkspace,
webView.Document.Context,
getSourceTextByModelId);
hoverProvider = new HoverProvider(
ClientSession.CompilationWorkspace,
webView.Document.Context,
getSourceTextByModelId);
}
public async Task <CompletionList> Handle(CompletionParams request, CancellationToken cancellationToken)
{
_log.LogInformation(string.Format(Resources.LoggingMessages.request_handle, _method));
try
{
var line = (int)request.Position.Line + 1;
var col = (int)request.Position.Character + 1;
var filerepo = _workspaceManager.GetFileRepository(request.TextDocument.Uri);
var codeLine = filerepo.PhysicalFile.GetSourceLine(line - 1);
var symbolmanager = filerepo.SymbolTableManager;
ICompletionProvider provider = new CompletionProvider(symbolmanager);
return(await Task.Run(() => provider.FindCompletionItems(request.TextDocument.Uri, line, col, codeLine),
cancellationToken));
}
catch (InvalidOperationException e)
{
_mss.SendInformation(e.Message);
return(null);
}
catch (Exception e)
{
HandleError(string.Format(Resources.LoggingMessages.request_error, _method), e);
return(null);
}
}
protected AbstractCompletionProviderTests(TWorkspaceFixture workspaceFixture)
{
MockCompletionSession = new Mock <ICompletionSession>(MockBehavior.Strict);
this.WorkspaceFixture = workspaceFixture;
this.CompletionProvider = CreateCompletionProvider();
}
public FileSystemCompletionHelper(
CompletionProvider completionProvider,
TextSpan textChangeSpan,
ICurrentWorkingDirectoryDiscoveryService fileSystemDiscoveryService,
Glyph folderGlyph,
Glyph fileGlyph,
ImmutableArray <string> searchPaths,
IEnumerable <string> allowableExtensions,
Func <string, bool> exclude = null,
CompletionItemRules itemRules = null)
{
Debug.Assert(searchPaths.All(path => PathUtilities.IsAbsolute(path)));
_completionProvider = completionProvider;
_textChangeSpan = textChangeSpan;
_searchPaths = searchPaths;
_allowableExtensions = allowableExtensions.Select(e => e.ToLowerInvariant()).ToSet();
_fileSystemDiscoveryService = fileSystemDiscoveryService;
_folderGlyph = folderGlyph;
_fileGlyph = fileGlyph;
_exclude = exclude;
_itemRules = itemRules;
_lazyGetDrives = new Lazy <string[]>(() =>
IOUtilities.PerformIO(Directory.GetLogicalDrives, SpecializedCollections.EmptyArray <string>()));
}
protected override void OnCompilationWorkspaceAvailable()
{
CodeCellId GetCodeCellId(string monacoModelId)
{
foreach (var codeCell in CodeCells.Values)
{
if (codeCell.Editor is CodeCellEditorView editor &&
!editor.IsDisposed && editor.GetMonacoModelId() == monacoModelId)
{
return(codeCell.CodeCellId);
}
}
return(default(CodeCellId));
}
completionProvider?.Dispose();
signatureHelpProvider?.Dispose();
hoverProvider?.Dispose();
completionProvider = new CompletionProvider(
ClientSession.CompilationWorkspace,
webView.Document.Context,
GetCodeCellId);
signatureHelpProvider = new SignatureHelpProvider(
ClientSession.CompilationWorkspace,
webView.Document.Context,
GetCodeCellId);
hoverProvider = new HoverProvider(
ClientSession.CompilationWorkspace,
webView.Document.Context,
GetCodeCellId);
}
public static CompletionContext GetContext(Document document, CompletionProvider provider, int position)
{
var context = new CompletionContext(provider, document, position,
new TextSpan(), CompletionTrigger.Default, document.Project.Solution.Workspace.Options,
default(CancellationToken));
return(context);
}
public GlobalAssemblyCacheCompletionHelper(
CompletionProvider completionProvider,
TextSpan textChangeSpan,
CompletionItemRules itemRules = null)
{
_completionProvider = completionProvider;
_textChangeSpan = textChangeSpan;
_itemRules = itemRules;
}
private static ImmutableHashSet <char> GetTriggerCharacters(CompletionProvider provider)
{
if (provider is LSPCompletionProvider lspProvider)
{
return(lspProvider.TriggerCharacters);
}
return(ImmutableHashSet <char> .Empty);
}
public RegexEmbeddedLanguageFeatures(
AbstractEmbeddedLanguageFeaturesProvider provider,
EmbeddedLanguageInfo info) : base(info)
{
_provider = provider;
DocumentHighlightsService = new RegexDocumentHighlightsService(this);
CompletionProvider = new RegexEmbeddedCompletionProvider(this);
}
protected void TestCommitCharacters(char[] commitCharacters)
{
foreach (var ch in commitCharacters)
{
Assert.True(CompletionProvider.IsCommitCharacter(null, ch, null), "Expected '" + ch + "' to be a commit character");
}
var chr = 'x';
Assert.False(CompletionProvider.IsCommitCharacter(null, chr, null), "Expected '" + chr + "' NOT to be a commit character");
}
protected override void OnAgentDisconnected()
{
completionProvider?.Dispose();
completionProvider = null;
signatureHelpProvider?.Dispose();
signatureHelpProvider = null;
hoverProvider?.Dispose();
hoverProvider = null;
}
internal static async Task <CompletionList> GetCompletionListAsync(CompletionProvider provider, Document document, int position, CompletionTrigger triggerInfo, OptionSet options = null)
{
var service = GetCompletionService(document);
var context = await GetCompletionListContextAsync(provider, document, position, triggerInfo, options);
var text = await document.GetTextAsync();
var span = service.GetDefaultItemSpan(text, position);
return(CompletionList.Create(span, context.Items.ToImmutableArray(), service.GetRules(), context.SuggestionModeItem));
}
public static IReadOnlyList <CompletionItem> GetCompletions(CompletionProvider provider, string source, string searchText)
{
int position = GetPosition(source, searchText);
var document = GetTestDocument(source);
var completionContext = GetContext(document, provider, position);
provider.ProvideCompletionsAsync(completionContext).Wait();
var completions = GetCompletions(completionContext);
return(completions);
}
public static IReadOnlyList <CompletionItem> GetCompletions(CompletionProvider provider, string source, string additinalFile, string searchText)
{
int position = source.IndexOf(searchText) + searchText.Length;
var document = GetTestDocument(source, additinalFile);
var completionContext = GetContext(document, provider, position);
provider.ProvideCompletionsAsync(completionContext).Wait();
var completions = GetCompletions(completionContext);
return(completions);
}
public RegexEmbeddedLanguage(
AbstractEmbeddedLanguageFeaturesProvider provider,
EmbeddedLanguageInfo info)
{
Info = info;
Classifier = new RegexSyntaxClassifier(info);
_provider = provider;
DocumentHighlightsService = new RegexDocumentHighlightsService(this);
CompletionProvider = new RegexEmbeddedCompletionProvider(this);
}
internal static async Task <CompletionContext> GetCompletionListContextAsync(CompletionProvider provider, Document document, int position, CompletionTrigger triggerInfo, OptionSet options = null)
{
options = options ?? document.Project.Solution.Workspace.Options;
var service = document.Project.LanguageServices.GetService <CompletionService>();
var text = await document.GetTextAsync();
var span = service.GetDefaultItemSpan(text, position);
var context = new CompletionContext(provider, document, position, span, triggerInfo, options, CancellationToken.None);
await provider.ProvideCompletionsAsync(context);
return(context);
}
public static async Task <IReadOnlyList <CompletionItem> > GetCompletions(CompletionProvider provider, Document document, string searchText)
{
var sourceText = await document.GetTextAsync();
int position = GetPosition(sourceText.ToString(), searchText);
var completionContext = GetContext(document, provider, position);
provider.ProvideCompletionsAsync(completionContext).Wait();
var completions = GetCompletions(completionContext);
return(completions);
}
protected async Task VerifyItemInEditorBrowsableContextsAsync(string markup, string referencedCode, string item, int expectedSymbolsSameSolution, int expectedSymbolsMetadataReference,
string sourceLanguage, string referencedLanguage, bool hideAdvancedMembers = false)
{
CompletionProvider = CreateCompletionProvider();
await VerifyItemWithMetadataReferenceAsync(markup, referencedCode, item, expectedSymbolsMetadataReference, sourceLanguage, referencedLanguage, hideAdvancedMembers);
await VerifyItemWithProjectReferenceAsync(markup, referencedCode, item, expectedSymbolsSameSolution, sourceLanguage, referencedLanguage, hideAdvancedMembers);
// If the source and referenced languages are different, then they cannot be in the same project
if (sourceLanguage == referencedLanguage)
{
await VerifyItemInSameProjectAsync(markup, referencedCode, item, expectedSymbolsSameSolution, sourceLanguage, hideAdvancedMembers);
}
}
protected void VerifySendEnterThroughToEnter(string displayText, string textTypedSoFar, bool sendThroughEnterEnabled, bool expected)
{
using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromFile(""))
{
var document = workspace.CurrentSolution.Projects.Single().Documents.Single();
var item = new CSharpCompletionItem(workspace, CompletionProvider, displayText, new TextSpan(0, 0), null, null);
var optionService = workspace.Services.GetService <IOptionService>();
var options = optionService.GetOptions().WithChangedOption(CSharpCompletionOptions.AddNewLineOnEnterAfterFullyTypedWord, sendThroughEnterEnabled);
optionService.SetOptions(options);
Assert.Equal(expected, CompletionProvider.SendEnterThroughToEditor(item, textTypedSoFar));
}
}
public void IsCommitCharacterTest()
{
var validCharacters = new[]
{
' ', '(', '{', '['
};
var invalidCharacters = new[]
{
'x', ',', '#'
};
foreach (var ch in validCharacters)
{
Assert.True(CompletionProvider.IsCommitCharacter(null, ch, null), "Expected '" + ch + "' to be a commit character");
}
foreach (var ch in invalidCharacters)
{
Assert.False(CompletionProvider.IsCommitCharacter(null, ch, null), "Expected '" + ch + "' to NOT be a commit character");
}
}
private void VerifyTextualTriggerCharacterWorker(string markup, bool expectedTriggerCharacter, bool triggerOnLetter)
{
using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromFile(markup))
{
var document = workspace.Documents.Single();
var position = document.CursorPosition.Value;
var text = document.TextBuffer.CurrentSnapshot.AsText();
var options = workspace.Options.WithChangedOption(CompletionOptions.TriggerOnTypingLetters, LanguageNames.CSharp, triggerOnLetter);
var isTextualTriggerCharacterResult = CompletionProvider.IsTriggerCharacter(text, position, options);
if (expectedTriggerCharacter)
{
var assertText = "'" + text.ToString(new Microsoft.CodeAnalysis.Text.TextSpan(position, 1)) + "' expected to be textual trigger character";
Assert.True(isTextualTriggerCharacterResult, assertText);
}
else
{
var assertText = "'" + text.ToString(new Microsoft.CodeAnalysis.Text.TextSpan(position, 1)) + "' expected to NOT be textual trigger character";
Assert.False(isTextualTriggerCharacterResult, assertText);
}
}
}
protected override Result <InitializeResult, ResponseError <InitializeErrorData> > Initialize(InitializeParams @params)
{
workspaceRoot = @params.RootUri;
project = new Project(workspaceRoot);
completionProvider = new CompletionProvider(project);
signatureHelpProvider = new SignatureHelpProvider(project);
hoverProvider = new HoverProvider(project);
project.Documents.OnChanged += DocumentChanged;
return(Result <InitializeResult, ResponseError <InitializeErrorData> > .Success(new InitializeResult
{
Capabilities = new ServerCapabilities
{
TextDocumentSync = TextDocumentSyncKind.Full,
CompletionProvider = new CompletionOptions
{
TriggerCharacters = new[]
{
".",
" "
},
ResolveProvider = false
},
SignatureHelpProvider = new SignatureHelpOptions
{
TriggerCharacters = new[]
{
"(",
","
}
},
HoverProvider = true
}
}));
}
public TestCompletionService(Workspace workspace, string language, CompletionProvider provider)
: base(workspace)
{
Language = language;
this.TestProviders = new[] { provider }.ToImmutableArray();
}
public MockAnalyzerReference(CompletionProvider completionProvider)
{
_completionProvider = completionProvider;
}
public static CompletionContext GetContext(Document document, CompletionProvider provider, int position)
{
return(new CompletionContext(provider, document, position,
new TextSpan(), CompletionTrigger.Invoke, document.Project.Solution.Workspace.Options,
default));
}
public async Task <CompletionResult> GetCompletionData(int position, char?triggerChar, bool useSignatureHelp)
{
return(await CompletionProvider?.GetCompletionData(position, triggerChar, useSignatureHelp));
}
public void TestEnter()
{
Assert.False(CompletionProvider.SendEnterThroughToEditor(null, null), "Expected false from SendEnterThroughToEditor()");
}
public static async Task <IReadOnlyList <CompletionItem> > GetCompletionsAsync(CompletionProvider provider, string source, string additinalFile, string searchText)
{
int position = GetPosition(source, searchText);
var document = GetTestDocument(source, additinalFile);
var completionContext = GetContext(document, provider, position);
await provider.ProvideCompletionsAsync(completionContext);
return(GetCompletions(completionContext));
}
public DateAndTimeEmbeddedLanguageFeatures(EmbeddedLanguageInfo info) : base(info)
{
CompletionProvider = new DateAndTimeEmbeddedCompletionProvider(this);
}
