public void TryExtractNamespace_WithStatic_ReturnsTruue()
{
// Arrange
var csharpAddUsing = "using static X.Y.Z;";
// Act
var res = AddUsingsCodeActionProviderFactory.TryExtractNamespace(csharpAddUsing, out var @namespace);
// Assert
Assert.True(res);
Assert.Equal("static X.Y.Z", @namespace);
}
public void TryExtractNamespace_ReturnsTrue()
{
// Arrange
var csharpAddUsing = "using Abc.Xyz;";
// Act
var res = AddUsingsCodeActionProviderFactory.TryExtractNamespace(csharpAddUsing, out var @namespace);
// Assert
Assert.True(res);
Assert.Equal("Abc.Xyz", @namespace);
}
public void TryExtractNamespace_Invalid_ReturnsFalse()
{
// Arrange
var csharpAddUsing = "Abc.Xyz;";
// Act
var res = AddUsingsCodeActionProviderFactory.TryExtractNamespace(csharpAddUsing, out var @namespace);
// Assert
Assert.False(res);
Assert.Empty(@namespace);
}
private static IEnumerable <RazorCodeAction> ProcessCodeActionsVS(
RazorCodeActionContext context,
IEnumerable <RazorCodeAction> codeActions)
{
var typeAccessibilityCodeActions = new List <RazorCodeAction>(1);
foreach (var codeAction in codeActions)
{
if (codeAction.Name.Equals(RazorPredefinedCodeFixProviderNames.FullyQualify, StringComparison.Ordinal))
{
var node = FindImplicitOrExplicitExpressionNode(context);
string action;
// The formatting pass of our Default code action resolver rejects
// implicit/explicit expressions. So if we're in an implicit expression,
// we run the remapping resolver responsible for simply remapping
// (without formatting) the resolved code action. We do not support
// explicit expressions due to issues with the remapping methodology
// risking document corruption.
if (node is null)
{
action = LanguageServerConstants.CodeActions.Default;
}
else if (node is CSharpImplicitExpressionSyntax)
{
action = LanguageServerConstants.CodeActions.UnformattedRemap;
}
else
{
continue;
}
typeAccessibilityCodeActions.Add(codeAction.WrapResolvableCSharpCodeAction(context, action));
}
// For add using suggestions, the code action title is of the form:
// `using System.Net;`
else if (codeAction.Name.Equals(RazorPredefinedCodeFixProviderNames.AddImport, StringComparison.Ordinal) &&
AddUsingsCodeActionProviderFactory.TryExtractNamespace(codeAction.Title, out var @namespace))
{
var newCodeAction = codeAction with {
Title = $"@using {@namespace}"
};
typeAccessibilityCodeActions.Add(newCodeAction.WrapResolvableCSharpCodeAction(context, LanguageServerConstants.CodeActions.AddUsing));
}
// Not a type accessibility code action
else
{
continue;
}
}
return(typeAccessibilityCodeActions);
private static bool TryProcessCodeActionVS(
RazorCodeActionContext context,
CodeAction codeAction,
Diagnostic diagnostic,
string associatedValue,
out ICollection <CodeAction> typeAccessibilityCodeActions)
{
CodeAction processedCodeAction = null;
// When there's only one FQN suggestion, code action title is of the form:
// `System.Net.Dns`
if (!codeAction.Title.Any(c => char.IsWhiteSpace(c)) &&
codeAction.Title.EndsWith(associatedValue, StringComparison.OrdinalIgnoreCase))
{
var fqn = codeAction.Title;
processedCodeAction = CreateFQNCodeAction(context, diagnostic, codeAction, fqn);
}
// When there are multiple FQN suggestions, the code action title is of the form:
// `Fully qualify 'Dns'`
else if (codeAction.Title.Equals($"Fully qualify '{associatedValue}'", StringComparison.OrdinalIgnoreCase))
{
// Not currently supported as we need O# CodeAction to support the CodeAction.Children field.
// processedCodeAction = codeAction.WrapResolvableCSharpCodeAction(context, LanguageServerConstants.CodeActions.FullyQualifyType);
typeAccessibilityCodeActions = Array.Empty <CodeAction>();
return(false);
}
// For add using suggestions, the code action title is of the form:
// `using System.Net;`
else if (AddUsingsCodeActionProviderFactory.TryExtractNamespace(codeAction.Title, out var @namespace))
{
codeAction.Title = $"@using {@namespace}";
processedCodeAction = codeAction.WrapResolvableCSharpCodeAction(context, LanguageServerConstants.CodeActions.AddUsing);
}
// Not a type accessibility code action
else
{
typeAccessibilityCodeActions = Array.Empty <CodeAction>();
return(false);
}
typeAccessibilityCodeActions = new[] { processedCodeAction };
return(true);
}
public async override Task <CodeAction?> ResolveAsync(
CSharpCodeActionParams csharpParams,
CodeAction codeAction,
CancellationToken cancellationToken)
{
if (csharpParams is null)
{
throw new ArgumentNullException(nameof(csharpParams));
}
if (codeAction is null)
{
throw new ArgumentNullException(nameof(codeAction));
}
cancellationToken.ThrowIfCancellationRequested();
var resolvedCodeAction = await ResolveCodeActionWithServerAsync(csharpParams.RazorFileUri, codeAction, cancellationToken).ConfigureAwait(false);
if (resolvedCodeAction?.Edit?.DocumentChanges is null)
{
// Unable to resolve code action with server, return original code action
return(codeAction);
}
if (resolvedCodeAction.Edit.DocumentChanges.Count() != 1)
{
// We don't yet support multi-document code actions, return original code action
return(codeAction);
}
var documentChanged = resolvedCodeAction.Edit.DocumentChanges.First();
if (!documentChanged.IsTextDocumentEdit)
{
// Only Text Document Edit changes are supported currently, return original code action
return(codeAction);
}
var addUsingTextEdit = documentChanged.TextDocumentEdit?.Edits.FirstOrDefault();
if (addUsingTextEdit is null)
{
// No text edit available
return(codeAction);
}
if (!AddUsingsCodeActionProviderFactory.TryExtractNamespace(addUsingTextEdit.NewText, out var @namespace))
{
// Invalid text edit, missing namespace
return(codeAction);
}
var documentSnapshot = await _projectSnapshotManagerDispatcher.RunOnDispatcherThreadAsync(() =>
{
_documentResolver.TryResolveDocument(csharpParams.RazorFileUri.GetAbsoluteOrUNCPath(), out var documentSnapshot);
return(documentSnapshot);
}, cancellationToken).ConfigureAwait(false);
if (documentSnapshot is null)
{
return(codeAction);
}
var text = await documentSnapshot.GetTextAsync().ConfigureAwait(false);
if (text is null)
{
return(null);
}
var codeDocument = await documentSnapshot.GetGeneratedOutputAsync().ConfigureAwait(false);
if (codeDocument.IsUnsupported())
{
return(null);
}
var documentVersion = await _projectSnapshotManagerDispatcher.RunOnDispatcherThreadAsync(() =>
{
_documentVersionCache.TryGetDocumentVersion(documentSnapshot, out var version);
return(version);
}, cancellationToken).ConfigureAwait(false);
var codeDocumentIdentifier = new OptionalVersionedTextDocumentIdentifier()
{
Uri = csharpParams.RazorFileUri,
Version = documentVersion.Value
};
var edit = AddUsingsCodeActionResolver.CreateAddUsingWorkspaceEdit(@namespace, codeDocument, codeDocumentIdentifier);
resolvedCodeAction = resolvedCodeAction with {
Edit = edit
};
return(resolvedCodeAction);
}
}
