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; } }