private static void __Execute(atom.Trace context, int level, UsingDirectiveSyntax data, string file)
{
context.
SetComment("using", HINT.DATA_TYPE).
SetUrl(file, __GetLine(data.GetLocation()), __GetPosition(data.GetLocation())).
Send(NAME.SOURCE.PREVIEW, NAME.TYPE.FILE, level, data.Name.ToString());
}
private static void CheckUsingDeclaration(SyntaxNodeAnalysisContext context, UsingDirectiveSyntax usingDirective)
{
if (!usingDirective.Parent.IsKind(SyntaxKind.NamespaceDeclaration))
{
// Usings outside of a namespace are always qualified.
return;
}
if (!usingDirective.StaticKeyword.IsKind(SyntaxKind.None))
{
// using static types is not considered.
return;
}
if (usingDirective.HasNamespaceAliasQualifier())
{
// global qualified namespaces are OK.
return;
}
var symbol = context.SemanticModel.GetSymbolInfo(usingDirective.Name, context.CancellationToken).Symbol;
if (symbol == null)
{
// if there is no symbol, do not proceed.
return;
}
if (symbol is INamedTypeSymbol typeSymbol &&
typeSymbol.IsTupleType())
{
symbol = typeSymbol.TupleUnderlyingType();
}
string symbolString = symbol.ToQualifiedString(usingDirective.Name);
string usingString = UsingDirectiveSyntaxToCanonicalString(usingDirective);
if ((symbolString != usingString) && !usingDirective.StartsWithAlias(context.SemanticModel, context.CancellationToken))
{
switch (symbol.Kind)
{
case SymbolKind.Namespace:
context.ReportDiagnostic(Diagnostic.Create(DescriptorNamespace, usingDirective.GetLocation(), symbolString));
break;
case SymbolKind.NamedType:
var containingNamespace = ((NamespaceDeclarationSyntax)usingDirective.Parent).Name.ToString();
if (containingNamespace != symbol.ContainingNamespace.ToString())
{
context.ReportDiagnostic(Diagnostic.Create(DescriptorType, usingDirective.GetLocation(), symbolString));
}
break;
}
}
}
private static void CheckUsingDeclarations(SyntaxNodeAnalysisContext context, SyntaxList <UsingDirectiveSyntax> usingDirectives)
{
UsingDirectiveSyntax lastStaticUsingDirective = null;
foreach (var usingDirective in usingDirectives)
{
if (usingDirective.IsPrecededByPreprocessorDirective())
{
lastStaticUsingDirective = null;
}
if (usingDirective.StaticKeyword.IsKind(SyntaxKind.StaticKeyword))
{
if (lastStaticUsingDirective != null)
{
var firstName = lastStaticUsingDirective.Name;
var secondName = usingDirective.Name;
if (NameSyntaxHelpers.Compare(firstName, secondName) > 0)
{
context.ReportDiagnostic(Diagnostic.Create(
Descriptor,
lastStaticUsingDirective.GetLocation(),
new[] { firstName.ToNormalizedString(), secondName.ToNormalizedString() }));
return;
}
}
lastStaticUsingDirective = usingDirective;
}
}
}
private void HandleUsingDirectiveSyntax(SyntaxNodeAnalysisContext context)
{
UsingDirectiveSyntax syntax = context.Node as UsingDirectiveSyntax;
if (syntax.Alias == null)
{
return;
}
CompilationUnitSyntax compilationUnit = syntax.Parent as CompilationUnitSyntax;
SyntaxList <UsingDirectiveSyntax>?usingDirectives = compilationUnit?.Usings;
if (!usingDirectives.HasValue)
{
NamespaceDeclarationSyntax namespaceDeclaration = syntax.Parent as NamespaceDeclarationSyntax;
usingDirectives = namespaceDeclaration?.Usings;
}
if (!usingDirectives.HasValue)
{
return;
}
bool foundCurrent = false;
foreach (var usingDirective in usingDirectives)
{
// we are only interested in nodes after the current node
if (usingDirective == syntax)
{
foundCurrent = true;
continue;
}
else if (!foundCurrent)
{
continue;
}
// ignore following using alias directives
if (usingDirective.Alias != null)
{
continue;
}
SymbolInfo symbolInfo = context.SemanticModel.GetSymbolInfo(usingDirective.Name, context.CancellationToken);
INamespaceSymbol followingNamespaceSymbol = symbolInfo.Symbol as INamespaceSymbol;
if (followingNamespaceSymbol == null)
{
continue;
}
string alias = syntax.Alias.Name.ToString();
string precedingNamespace = followingNamespaceSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat);
// Using alias directive for '{alias}' must appear after directive for '{precedingNamespace}'
context.ReportDiagnostic(Diagnostic.Create(Descriptor, syntax.GetLocation(), alias, precedingNamespace));
break;
}
}
private static void ReportDiagnostic(SyntaxNodeAnalysisContext context,
UsingDirectiveSyntax usingDirectiveSyntax, string targetLayer)
{
var diagnostic = Diagnostic.Create(Rule, usingDirectiveSyntax.GetLocation(),
targetLayer);
context.ReportDiagnostic(diagnostic);
}
public static void Analyze(SyntaxNodeAnalysisContext context, UsingDirectiveSyntax usingDirective)
{
if (usingDirective.Alias != null)
{
context.ReportDiagnostic(
DiagnosticDescriptors.AvoidUsageOfUsingAliasDirective,
usingDirective.GetLocation());
}
}
private void HandleUsingDirectiveSyntax(SyntaxNodeAnalysisContext context)
{
UsingDirectiveSyntax syntax = context.Node as UsingDirectiveSyntax;
if (syntax.Alias?.Name?.IsMissing != false)
{
return;
}
CompilationUnitSyntax compilationUnit = syntax.Parent as CompilationUnitSyntax;
SyntaxList <UsingDirectiveSyntax>?usingDirectives = compilationUnit?.Usings;
if (!usingDirectives.HasValue)
{
NamespaceDeclarationSyntax namespaceDeclaration = syntax.Parent as NamespaceDeclarationSyntax;
usingDirectives = namespaceDeclaration?.Usings;
}
if (!usingDirectives.HasValue)
{
return;
}
foreach (var usingDirective in usingDirectives)
{
// we are only interested in nodes before the current node
if (usingDirective == syntax)
{
continue;
}
// only interested in using alias directives
if (usingDirective.Alias?.Name?.IsMissing != false)
{
continue;
}
string alias = syntax.Alias.Name.ToString();
string precedingAlias = usingDirective.Alias.Name.ToString();
if (string.Compare(alias, precedingAlias, StringComparison.OrdinalIgnoreCase) >= 0)
{
continue;
}
// Using alias directive for '{alias}' must appear before using alias directive for '{precedingAlias}'
context.ReportDiagnostic(Diagnostic.Create(Descriptor, syntax.GetLocation(), alias, precedingAlias));
break;
}
}
private static void CheckIncorrectlyOrderedUsingsAndReportDiagnostic(SyntaxNodeAnalysisContext context, IEnumerable <UsingDirectiveSyntax> usings)
{
UsingDirectiveSyntax previousUsingDirective = null;
foreach (var directive in usings)
{
if (previousUsingDirective != null)
{
if (NameSyntaxHelpers.Compare(previousUsingDirective.Name, directive.Name) > 0)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, previousUsingDirective.GetLocation()));
}
}
previousUsingDirective = directive;
}
}
private static void CheckIncorrectlyOrderedUsingsAndReportDiagnostic(SyntaxNodeAnalysisContext context, IEnumerable <UsingDirectiveSyntax> usings)
{
UsingDirectiveSyntax previousUsingDirective = null;
foreach (var directive in usings)
{
if (previousUsingDirective != null)
{
if (CultureInfo.InvariantCulture.CompareInfo.Compare(previousUsingDirective.Name.ToNormalizedString(), directive.Name.ToNormalizedString(), CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreWidth) > 0)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, previousUsingDirective.GetLocation()));
}
}
previousUsingDirective = directive;
}
}
private static void CheckUsingDeclarations(SyntaxNodeAnalysisContext context, SyntaxList <UsingDirectiveSyntax> usingDirectives)
{
UsingDirectiveSyntax lastStaticUsingDirective = null;
foreach (var usingDirective in usingDirectives)
{
if (usingDirective.StaticKeyword.IsKind(SyntaxKind.StaticKeyword))
{
lastStaticUsingDirective = usingDirective;
}
else if (lastStaticUsingDirective != null && !usingDirective.IsPrecededByPreprocessorDirective())
{
// only report a single diagnostic for the last static using directive that is followed by a non-static using directive
context.ReportDiagnostic(Diagnostic.Create(Descriptor, lastStaticUsingDirective.GetLocation()));
break;
}
}
}
public override SyntaxNode?VisitUsingDirective(UsingDirectiveSyntax node)
{
if (node.Parent.IsKind(SyntaxKind.CompilationUnit))
{
Diagnostic diagnostic;
if (node.StaticKeyword.IsKind(SyntaxKind.StaticKeyword))
{
diagnostic = DiagnosticDescriptors.EMBED0009_UsingStaticDirective(node.GetLocation());
}
else if (node.Alias != null)
{
diagnostic = DiagnosticDescriptors.EMBED0010_UsingAliasDirective(node.GetLocation());
}
else
{
goto Fin;
}
reporter.ReportDiagnostic(diagnostic);
}
Fin : return(base.VisitUsingDirective(node));
}
private static void CheckUsingDeclarations(SyntaxNodeAnalysisContext context, SyntaxList <UsingDirectiveSyntax> usingDirectives)
{
UsingDirectiveSyntax lastStaticUsingDirective = null;
foreach (var usingDirective in usingDirectives)
{
if (usingDirective.StaticKeyword.IsKind(SyntaxKind.StaticKeyword))
{
if (lastStaticUsingDirective != null && !usingDirective.IsPrecededByPreprocessorDirective())
{
var firstName = lastStaticUsingDirective.Name.ToUnaliasedString();
var secondName = usingDirective.Name.ToUnaliasedString();
if (string.Compare(firstName, secondName, StringComparison.OrdinalIgnoreCase) > 0)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, lastStaticUsingDirective.GetLocation(), new[] { firstName, secondName }));
return;
}
}
lastStaticUsingDirective = usingDirective;
}
}
}
private void HandleUsingDirectiveSyntax(SyntaxNodeAnalysisContext context)
{
UsingDirectiveSyntax syntax = context.Node as UsingDirectiveSyntax;
if (syntax.Alias != null)
{
return;
}
SemanticModel semanticModel = context.SemanticModel;
INamespaceSymbol namespaceSymbol;
string topLevelNamespace = GetTopLevelNamespace(semanticModel, syntax, out namespaceSymbol, context.CancellationToken);
if (!"System".Equals(topLevelNamespace, StringComparison.Ordinal))
{
return;
}
CompilationUnitSyntax compilationUnit = syntax.Parent as CompilationUnitSyntax;
SyntaxList <UsingDirectiveSyntax>?usingDirectives = compilationUnit?.Usings;
if (!usingDirectives.HasValue)
{
NamespaceDeclarationSyntax namespaceDeclaration = syntax.Parent as NamespaceDeclarationSyntax;
usingDirectives = namespaceDeclaration?.Usings;
}
if (!usingDirectives.HasValue)
{
return;
}
foreach (var usingDirective in usingDirectives)
{
// we are only interested in nodes before the current node
if (usingDirective == syntax)
{
break;
}
// ignore using alias directives, since they are handled by SA1209
if (usingDirective.Alias != null)
{
continue;
}
INamespaceSymbol precedingNamespaceSymbol;
string precedingTopLevelNamespace = GetTopLevelNamespace(semanticModel, usingDirective, out precedingNamespaceSymbol, context.CancellationToken);
if (precedingTopLevelNamespace == null || "System".Equals(precedingTopLevelNamespace, StringComparison.Ordinal))
{
continue;
}
string @namespace = namespaceSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat);
string precedingNamespace = precedingNamespaceSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat);
// Using directive for '{namespace}' must appear before directive for '{precedingNamespace}'
context.ReportDiagnostic(Diagnostic.Create(Descriptor, syntax.GetLocation(), @namespace, precedingNamespace));
break;
}
}
