|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Composition;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.Completion;
using Microsoft.CodeAnalysis.Completion.Providers;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.ErrorReporting;
using Microsoft.CodeAnalysis.Host.Mef;
using Microsoft.CodeAnalysis.LanguageService;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.Text;
namespace Microsoft.CodeAnalysis.CSharp.Completion.Providers;
[ExportCompletionProvider(nameof(FunctionPointerUnmanagedCallingConventionCompletionProvider), LanguageNames.CSharp)]
[ExtensionOrder(After = nameof(AggregateEmbeddedLanguageCompletionProvider))]
[Shared]
internal sealed partial class FunctionPointerUnmanagedCallingConventionCompletionProvider : LSPCompletionProvider
{
[ImportingConstructor]
[Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
public FunctionPointerUnmanagedCallingConventionCompletionProvider()
{
}
internal override string Language => LanguageNames.CSharp;
public override bool IsInsertionTrigger(SourceText text, int characterPosition, CompletionOptions options)
=> CompletionUtilities.IsTriggerCharacter(text, characterPosition, options);
public override ImmutableHashSet<char> TriggerCharacters { get; } = CompletionUtilities.CommonTriggerCharacters;
private static readonly ImmutableArray<string> s_predefinedCallingConventions = ["Cdecl", "Fastcall", "Thiscall", "Stdcall"];
public override async Task ProvideCompletionsAsync(CompletionContext context)
{
try
{
var document = context.Document;
var position = context.Position;
var cancellationToken = context.CancellationToken;
var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
if (syntaxTree.IsInNonUserCode(position, cancellationToken))
{
return;
}
var token = syntaxTree
.FindTokenOnLeftOfPosition(position, cancellationToken)
.GetPreviousTokenIfTouchingWord(position);
if (token.Kind() is not (SyntaxKind.OpenBracketToken or SyntaxKind.CommaToken))
{
return;
}
if (token.Parent is not FunctionPointerUnmanagedCallingConventionListSyntax callingConventionList)
{
return;
}
var contextPosition = token.SpanStart;
var semanticModel = await document.ReuseExistingSpeculativeModelAsync(callingConventionList, cancellationToken).ConfigureAwait(false);
var completionItems = new HashSet<CompletionItem>(CompletionItemComparer.Instance);
AddTypes(completionItems, contextPosition, semanticModel, cancellationToken);
// Even if we didn't have types, there are four magic calling conventions recognized regardless.
// We add these after doing the type lookup so if we had types we can show that instead
foreach (var callingConvention in s_predefinedCallingConventions)
{
completionItems.Add(CompletionItem.Create(callingConvention, tags: GlyphTags.GetTags(Glyph.Keyword)));
}
context.AddItems(completionItems);
}
catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, ErrorSeverity.General))
{
// nop
}
}
private static void AddTypes(HashSet<CompletionItem> completionItems, int contextPosition, SemanticModel semanticModel, CancellationToken cancellationToken)
{
// We have to find the set of types that meet the criteria listed in
// https://github.com/dotnet/csharplang/blob/main/proposals/csharp-9.0/function-pointers.md#mapping-the-calling_convention_specifier-to-a-callkind
// We skip the check of an type being in the core assembly since that's not really necessary for our work.
var compilerServicesNamespace = semanticModel.Compilation.GlobalNamespace.GetQualifiedNamespace("System.Runtime.CompilerServices");
if (compilerServicesNamespace == null)
{
return;
}
foreach (var type in compilerServicesNamespace.GetTypeMembers())
{
cancellationToken.ThrowIfCancellationRequested();
const string CallConvPrefix = "CallConv";
if (type.DeclaredAccessibility == Accessibility.Public && type.Name.StartsWith(CallConvPrefix))
{
var displayName = type.Name[CallConvPrefix.Length..];
completionItems.Add(
SymbolCompletionItem.CreateWithSymbolId(
displayName,
[type],
rules: CompletionItemRules.Default,
contextPosition));
}
}
}
internal override Task<CompletionDescription> GetDescriptionWorkerAsync(Document document, CompletionItem item, CompletionOptions options, SymbolDescriptionOptions displayOptions, CancellationToken cancellationToken)
=> SymbolCompletionItem.GetDescriptionAsync(item, document, displayOptions, cancellationToken);
private sealed class CompletionItemComparer : IEqualityComparer<CompletionItem>
{
public static readonly IEqualityComparer<CompletionItem> Instance = new CompletionItemComparer();
public bool Equals(CompletionItem? x, CompletionItem? y)
{
return x?.DisplayText == y?.DisplayText;
}
public int GetHashCode(CompletionItem obj)
{
return obj?.DisplayText.GetHashCode() ?? 0;
}
}
}
|