private void ClassifyNullableDirective(NullableDirectiveTriviaSyntax node)
{
AddClassification(node.HashToken, ClassificationTypeNames.PreprocessorKeyword);
AddClassification(node.NullableKeyword, ClassificationTypeNames.PreprocessorKeyword);
AddClassification(node.SettingToken, ClassificationTypeNames.PreprocessorKeyword);
ClassifyDirectiveTrivia(node);
}
private async Task<Document> AddNullableComment(Document document, NullableDirectiveTriviaSyntax nullableDirectiveTrivia, CancellationToken cancellationToken)
{
SyntaxNode root = await document.GetSyntaxRootAsync().ConfigureAwait(false);
SyntaxTrivia endOfLine = SyntaxFactory.EndOfLine("\r\n");
var newDirective = nullableDirectiveTrivia.WithLeadingTrivia(SyntaxFactory.Comment(NullableReferenceTypeAnalyzer.NullableSyntaxMarker.Start), endOfLine)
.WithTrailingTrivia(endOfLine, SyntaxFactory.Comment(NullableReferenceTypeAnalyzer.NullableSyntaxMarker.End), endOfLine);
return document.WithSyntaxRoot(root.ReplaceNode(nullableDirectiveTrivia, newDirective));
}
public override void VisitNullableDirectiveTrivia(NullableDirectiveTriviaSyntax node)
{
// if (debug) Console.WriteLine(node.ToFullString());
// Todo("NullableDirectiveTrivia"); var nl = OurLine.NewLine(LineKind.Decl, "NullableDirectiveTrivia");
// nl.Source = node.ToFullString();
// nl.ParentKind = node.Parent.RawKind;
// nl.RawKind = node.RawKind;
// LogCommand(nl);
base.VisitNullableDirectiveTrivia(node);
}
public override TypeWithNode VisitNullableDirectiveTrivia(NullableDirectiveTriviaSyntax node)
{
if (node.SettingToken.IsKind(SyntaxKind.RestoreKeyword))
{
currentMode = NullableMode.Infer;
}
else if (node.SettingToken.IsKind(SyntaxKind.EnableKeyword))
{
currentMode = NullableMode.Enable;
}
else if (node.SettingToken.IsKind(SyntaxKind.DisableKeyword))
{
currentMode = NullableMode.Disable;
}
return(base.VisitNullableDirectiveTrivia(node));
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
// TODO: Replace the following code with your own analysis, generating a CodeAction for each fix to suggest
Diagnostic diagnostic = context.Diagnostics.First();
TextSpan diagnosticSpan = diagnostic.Location.SourceSpan;
// Find the type declaration identified by the diagnostic.
IEnumerable <SyntaxNode> ancestorsAndSelf = root.FindToken(diagnosticSpan.Start).Parent.AncestorsAndSelf();
NullableTypeSyntax nullableTypeSyntax = ancestorsAndSelf.OfType <NullableTypeSyntax>().FirstOrDefault();
TypeConstraintSyntax typeConstraint = ancestorsAndSelf.OfType <TypeConstraintSyntax>().FirstOrDefault();
NullableDirectiveTriviaSyntax nullableDirective = root.FindTrivia(diagnosticSpan.Start).GetStructure() as NullableDirectiveTriviaSyntax;
if (nullableTypeSyntax == null && typeConstraint == null && nullableDirective == null)
{
return;
}
// Register a code action that will invoke the fix.
Func <CancellationToken, Task <Document> > fix;
if (nullableTypeSyntax != null)
{
fix = c => AddNullableComment(context.Document, nullableTypeSyntax, c);
}
else if (typeConstraint != null)
{
fix = c => AddNullableComment(context.Document, typeConstraint, c);
}
else
{
fix = c => AddNullableComment(context.Document, nullableDirective, c);
}
CodeAction codeAction = CodeAction.Create(title, fix, title);
context.RegisterCodeFix(codeAction, diagnostic);
}
public override SyntaxNode?VisitNullableDirectiveTrivia(NullableDirectiveTriviaSyntax node)
{
isActive = node.SettingToken.IsKind(SyntaxKind.RestoreKeyword);
return(base.VisitNullableDirectiveTrivia(node));
}
public override void VisitNullableDirectiveTrivia(NullableDirectiveTriviaSyntax node)
{
Log(node, "Unsupported Syntax !");
}
public override void VisitNullableDirectiveTrivia(NullableDirectiveTriviaSyntax node)
{
new Entities.NullableDirective(cx, node);
}
// // Summary: // Called when the visitor visits a NullableDirectiveTriviaSyntax node. public virtual void VisitNullableDirectiveTrivia(NullableDirectiveTriviaSyntax node);
internal static NullableContextOptions?GetNullableContextOptions(NullableContextOptions compilationOptions, NullableContextOptions?options, NullableDirectiveTriviaSyntax directive)
{
if (!directive.TargetToken.IsKind(SyntaxKind.None))
{
if (options is not {
} knownState)
{
return(null);
}
NullableContextOptions flagToChange;
if (directive.TargetToken.IsKind(SyntaxKind.AnnotationsKeyword))
{
flagToChange = NullableContextOptions.Annotations;
}
else if (directive.TargetToken.IsKind(SyntaxKind.WarningsKeyword))
{
flagToChange = NullableContextOptions.Warnings;
}
else
{
return(null);
}
if (directive.SettingToken.IsKind(SyntaxKind.EnableKeyword))
{
return(knownState | flagToChange);
}
else if (directive.SettingToken.IsKind(SyntaxKind.DisableKeyword))
{
return(knownState & (~flagToChange));
}
else
{
return(null);
}
}
if (directive.SettingToken.IsKind(SyntaxKind.EnableKeyword))
{
return(NullableContextOptions.Annotations | NullableContextOptions.Warnings);
}
else if (directive.SettingToken.IsKind(SyntaxKind.DisableKeyword))
{
return(NullableContextOptions.Disable);
}
else if (directive.SettingToken.IsKind(SyntaxKind.RestoreKeyword))
{
return(compilationOptions);
}
else
{
return(null);
}
}
