private static List <string> GetErrorCodes(PragmaWarningDirectiveTriviaSyntax pragmaWarningDirectiveTrivia)
{
return(pragmaWarningDirectiveTrivia.ErrorCodes
.OfType <IdentifierNameSyntax>()
.Select(x => x.Identifier.ValueText)
.ToList());
}
private static Task <Document> RefactorAsync(
Document document,
PragmaWarningDirectiveTriviaSyntax directive,
CancellationToken cancellationToken)
{
SyntaxTrivia trivia = directive.ParentTrivia;
SyntaxTriviaList list = trivia.GetContainingList();
int index = list.IndexOf(trivia);
int start = directive.EndOfDirectiveToken.SpanStart;
StringBuilder sb = StringBuilderCache.GetInstance();
int i = index + 1;
SyntaxKind disableOrRestoreKind = directive.DisableOrRestoreKeyword.Kind();
int end = start;
bool addComma = !directive.ErrorCodes.HasTrailingSeparator();
while (i < list.Count)
{
SyntaxTrivia trivia2 = list[i];
if (trivia2.IsWhitespaceOrEndOfLineTrivia())
{
i++;
continue;
}
if (trivia2.GetStructure() is PragmaWarningDirectiveTriviaSyntax directive2 &&
disableOrRestoreKind == directive2.DisableOrRestoreKeyword.Kind())
{
if (addComma)
{
sb.Append(",");
}
sb.Append(" ");
SeparatedSyntaxList <ExpressionSyntax> errorCodes = directive2.ErrorCodes;
sb.Append(errorCodes.ToString());
addComma = !errorCodes.HasTrailingSeparator();
end = directive2.ErrorCodes.Span.End;
}
i++;
}
return(document.WithTextChangeAsync(
TextSpan.FromBounds(start, end),
StringBuilderCache.GetStringAndFree(sb),
cancellationToken));
}
public override SyntaxNode VisitPragmaWarningDirectiveTrivia(PragmaWarningDirectiveTriviaSyntax node)
{
node = (PragmaWarningDirectiveTriviaSyntax)base.VisitPragmaWarningDirectiveTrivia(node);
node = node.WithPragmaKeyword(node.PragmaKeyword.WithTrailingTrivia(Space));
node = node.WithWarningKeyword(node.WarningKeyword.WithTrailingTrivia(Space));
node = node.WithDisableOrRestoreKeyword(node.DisableOrRestoreKeyword.WithTrailingTrivia(Space));
return(node);
}
public override void VisitPragmaWarningDirectiveTrivia(PragmaWarningDirectiveTriviaSyntax node)
{
var res = node.ToString().Split(new char[] { }, 3, StringSplitOptions.RemoveEmptyEntries);
if (res.Length >= 2)
{
this.pragmas.Add(new KeyValuePair <string, string>(res[1], res[2]));
}
}
public override void VisitPragmaWarningDirectiveTrivia(PragmaWarningDirectiveTriviaSyntax node)
{
if (!PreVisit(node))
{
return;
}
base.VisitPragmaWarningDirectiveTrivia(node);
PostVisit(node);
}
public override void VisitPragmaWarningDirectiveTrivia(PragmaWarningDirectiveTriviaSyntax node)
{
// if (debug) Console.WriteLine(node.ToFullString());
// Todo("PragmaWarningDirectiveTrivia"); var nl = OurLine.NewLine(LineKind.Decl, "PragmaWarningDirectiveTrivia");
// nl.Source = node.ToFullString();
// nl.ParentKind = node.Parent.RawKind;
// nl.RawKind = node.RawKind;
// LogCommand(nl);
// Todo("PragmaWarningDirectiveTrivia");
base.VisitPragmaWarningDirectiveTrivia(node);
}
private void ClassifyPragmaWarningDirective(PragmaWarningDirectiveTriviaSyntax node)
{
AddClassification(node.HashToken, ClassificationTypeNames.PreprocessorKeyword);
AddClassification(node.PragmaKeyword, ClassificationTypeNames.PreprocessorKeyword);
AddClassification(node.WarningKeyword, ClassificationTypeNames.PreprocessorKeyword);
AddClassification(node.DisableOrRestoreKeyword, ClassificationTypeNames.PreprocessorKeyword);
foreach (var nodeOrToken in node.ErrorCodes.GetWithSeparators())
{
ClassifyNodeOrToken(nodeOrToken);
}
}
private void Analyze(SyntaxNodeAnalysisContext context)
{
PragmaWarningDirectiveTriviaSyntax pragma = context.Node as PragmaWarningDirectiveTriviaSyntax;
if (pragma == null)
{
return;
}
CSharpSyntaxNode violation = pragma;
Diagnostic diagnostic = Diagnostic.Create(Rules[0], violation.GetLocation());
context.ReportDiagnostic(diagnostic);
}
private QuickInfoItem?GetQuickinfoForPragmaWarning(Document document, SyntaxToken token)
{
var errorCodeNode = token.Parent switch
{
PragmaWarningDirectiveTriviaSyntax directive
=> token.IsKind(SyntaxKind.EndOfDirectiveToken)
? directive.ErrorCodes.LastOrDefault()
: directive.ErrorCodes.FirstOrDefault(),
{ Parent : PragmaWarningDirectiveTriviaSyntax } node => node,
_ => null,
};
if (errorCodeNode is null)
{
return(null);
}
// https://docs.microsoft.com/en-US/dotnet/csharp/language-reference/preprocessor-directives/preprocessor-pragma-warning
// warning-list: A comma-separated list of warning numbers. The "CS" prefix is optional.
// errorCodeNode is single error code from the comma separated list
var errorCode = errorCodeNode switch
{
// case CS0219 or SA0012:
IdentifierNameSyntax identifierName => identifierName.Identifier.ValueText,
// case 0219 or 219:
// Take the number and add the "CS" prefix.
LiteralExpressionSyntax
{
RawKind : (int)SyntaxKind.NumericLiteralExpression
} literal
=> int.TryParse(literal.Token.ValueText, out var errorCodeNumber)
? $"CS{errorCodeNumber:0000}"
: literal.Token.ValueText,
_ => null,
};
if (errorCode is null)
{
return(null);
}
return(GetQuickInfoFromSupportedDiagnosticsOfProjectAnalyzers(
document,
errorCode,
errorCodeNode.Span
));
}
private void ClassifyPragmaWarningDirective(PragmaWarningDirectiveTriviaSyntax node)
{
AddClassification(node.HashToken, ClassificationTypeNames.PreprocessorKeyword);
AddClassification(node.PragmaKeyword, ClassificationTypeNames.PreprocessorKeyword);
AddClassification(node.WarningKeyword, ClassificationTypeNames.PreprocessorKeyword);
AddClassification(node.DisableOrRestoreKeyword, ClassificationTypeNames.PreprocessorKeyword);
foreach (var nodeOrToken in node.ErrorCodes.GetWithSeparators())
{
ClassifyNodeOrToken(nodeOrToken);
}
if (node.ErrorCodes.Count == 0)
{
// When there are no error codes, we need to classify the directive's trivia.
// (When there are error codes, ClassifyNodeOrToken above takes care of that.)
ClassifyDirectiveTrivia(node);
}
}
private QuickInfoItem?GetQuickinfoForPragmaWarning(Document document, SyntaxToken token)
{
var errorCode = token.Parent switch
{
PragmaWarningDirectiveTriviaSyntax directive
=> token.IsKind(SyntaxKind.EndOfDirectiveToken)
? directive.ErrorCodes.LastOrDefault() as IdentifierNameSyntax
: directive.ErrorCodes.FirstOrDefault() as IdentifierNameSyntax,
IdentifierNameSyntax {
Parent : PragmaWarningDirectiveTriviaSyntax _
} identifier
=> identifier,
_ => null,
};
if (errorCode != null)
{
return(GetQuickInfoFromSupportedDiagnosticsOfProjectAnalyzers(document, errorCode.Identifier.ValueText, errorCode.Span));
}
return(null);
}
private void ClassifyPragmaWarningDirective(PragmaWarningDirectiveTriviaSyntax node)
{
AddClassification(node.HashToken, ClassificationTypeNames.PreprocessorKeyword);
AddClassification(node.PragmaKeyword, ClassificationTypeNames.PreprocessorKeyword);
AddClassification(node.WarningKeyword, ClassificationTypeNames.PreprocessorKeyword);
AddClassification(node.DisableOrRestoreKeyword, ClassificationTypeNames.PreprocessorKeyword);
foreach (var nodeOrToken in node.ErrorCodes.GetWithSeparators())
{
ClassifyNodeOrToken(nodeOrToken);
}
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitPragmaWarningDirectiveTrivia(PragmaWarningDirectiveTriviaSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitPragmaWarningDirectiveTrivia(node);
}
public override void VisitPragmaWarningDirectiveTrivia(PragmaWarningDirectiveTriviaSyntax node)
{
Debug.Fail(node.ToString());
base.VisitPragmaWarningDirectiveTrivia(node);
}
public override Evaluation VisitPragmaWarningDirectiveTrivia(PragmaWarningDirectiveTriviaSyntax node)
{
return(base.VisitPragmaWarningDirectiveTrivia(node));
}
public override void VisitPragmaWarningDirectiveTrivia(PragmaWarningDirectiveTriviaSyntax node)
{
throw new NotImplementedException();
}
public override Ust VisitPragmaWarningDirectiveTrivia(PragmaWarningDirectiveTriviaSyntax node)
{
throw new InvalidOperationException();
}
public override void VisitPragmaWarningDirectiveTrivia(PragmaWarningDirectiveTriviaSyntax node)
{
}
public override SyntaxNode VisitPragmaWarningDirectiveTrivia(PragmaWarningDirectiveTriviaSyntax node)
{
node = (PragmaWarningDirectiveTriviaSyntax)base.VisitPragmaWarningDirectiveTrivia(node);
Classes.Add(node);
return(node);
}
public override void VisitPragmaWarningDirectiveTrivia(PragmaWarningDirectiveTriviaSyntax node)
{
new Entities.PragmaWarningDirective(cx, node);
}
// // Summary: // Called when the visitor visits a PragmaWarningDirectiveTriviaSyntax node. public virtual void VisitPragmaWarningDirectiveTrivia(PragmaWarningDirectiveTriviaSyntax node);
public TamePragmaWarningDirectiveTriviaSyntax(PragmaWarningDirectiveTriviaSyntax node)
{
Node = node;
AddChildren();
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitPragmaWarningDirectiveTrivia(PragmaWarningDirectiveTriviaSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitPragmaWarningDirectiveTrivia(node);
}
