private void AnalyzeCompilation(CompilationAnalysisContext context)
{
if (AssemblyHasPublicTypes(context.Compilation.Assembly))
{
var comVisibleAttributeSymbol = WellKnownTypes.ComVisibleAttribute(context.Compilation);
if (comVisibleAttributeSymbol == null)
{
return;
}
var attributeInstance = context.Compilation.Assembly.GetAttributes().FirstOrDefault(a => a.AttributeClass.Equals(comVisibleAttributeSymbol));
if (attributeInstance != null)
{
if (attributeInstance.ConstructorArguments.Length > 0 &&
attributeInstance.ConstructorArguments[0].Kind == TypedConstantKind.Primitive &&
attributeInstance.ConstructorArguments[0].Value != null &
attributeInstance.ConstructorArguments[0].Value.Equals(true))
{
// Has the attribute, with the value 'true'.
context.ReportDiagnostic(Diagnostic.Create(Rule, Location.None, string.Format(SystemRuntimeAnalyzersResources.CA1017_AttributeTrue, context.Compilation.Assembly.Name)));
}
}
else
{
// No ComVisible attribute at all.
context.ReportDiagnostic(Diagnostic.Create(Rule, Location.None, string.Format(SystemRuntimeAnalyzersResources.CA1017_NoAttribute, context.Compilation.Assembly.Name)));
}
}
return;
}
private static void AnalyzeCompilation(CompilationAnalysisContext context)
{
if (AssemblyHasPublicTypes(context.Compilation.Assembly))
{
INamedTypeSymbol comVisibleAttributeSymbol = WellKnownTypes.ComVisibleAttribute(context.Compilation);
if (comVisibleAttributeSymbol == null)
{
return;
}
AttributeData attributeInstance = context.Compilation.Assembly.GetAttributes().FirstOrDefault(a => a.AttributeClass.Equals(comVisibleAttributeSymbol));
if (attributeInstance != null)
{
if (attributeInstance.ConstructorArguments.Length > 0 &&
attributeInstance.ConstructorArguments[0].Kind == TypedConstantKind.Primitive &&
attributeInstance.ConstructorArguments[0].Value != null &
attributeInstance.ConstructorArguments[0].Value.Equals(true))
{
// Has the attribute, with the value 'true'.
context.ReportDiagnostic(Diagnostic.Create(RuleA, Location.None, context.Compilation.Assembly.Name));
}
}
else
{
// No ComVisible attribute at all.
context.ReportDiagnostic(Diagnostic.Create(RuleB, Location.None, context.Compilation.Assembly.Name));
}
}
return;
}
private void AnalyzeCompilation(CompilationAnalysisContext context)
{
Trace.WriteLine("AnalyzeCompilation");
try
{
INamedTypeSymbol dbContextTypeSymbol;
IEnumerable<INamedTypeSymbol> entityTypeSymbols = SymbolHelper.GetAllEntityTypesFromDbContext(context.Compilation, out dbContextTypeSymbol);
if (!entityTypeSymbols.Any())
{
return;
}
var allTypeSymbols = context.Compilation.GetSymbolsWithName(s => !s.EndsWith("DbContext"), SymbolFilter.Type).Cast<INamedTypeSymbol>();
var allMemberSymbols = allTypeSymbols.SelectMany(t => t.GetMembers().Where(m => m.Kind == SymbolKind.Property));
Trace.WriteLine("Class count: " + allTypeSymbols.Count());
Trace.WriteLine("Property count: " + allMemberSymbols.Count());
var efRoslynTheorem = new EFRoslynTheorem();
var result = efRoslynTheorem.Solve(entityTypeSymbols);
if (result.Status == Status.Unsatisfiable)
{
var classAssumptions = efRoslynTheorem.ClassAssumptions.ToList();
var propertyAssumptions = efRoslynTheorem.PropertyAssumptions.OrderBy(pa => pa.Rank).ToList();
do
{
result = TryToRemoveWrongAssumption(efRoslynTheorem, result, classAssumptions, propertyAssumptions);
} while (result != null && result.Status != Status.Satisfiable);
if (result == null || result.Status != Status.Satisfiable)
{
var diagnostic2 = Diagnostic.Create(UnsatisfiableRule, dbContextTypeSymbol.Locations[0], dbContextTypeSymbol.Name);
Trace.WriteLine("ReportDiagnostic " + diagnostic2.Descriptor.Id);
context.ReportDiagnostic(diagnostic2);
return;
}
var cacheId = EFRoslynTheoremCache.Add(context.Compilation, efRoslynTheorem, result);
var props = ImmutableDictionary.Create<string, string>();
props = props.Add("CacheId", cacheId);
var diagnostic = Diagnostic.Create(SatisfiableRule, dbContextTypeSymbol.Locations[0], props, dbContextTypeSymbol.Name);
Trace.WriteLine("ReportDiagnostic " + diagnostic.Descriptor.Id);
context.ReportDiagnostic(diagnostic);
}
}
catch (Exception ex)
{
Trace.WriteLine(ex.ToString());
throw;
}
}
private static bool AnalyzeIdentifierTaskContinueWith(SyntaxNode method, CompilationAnalysisContext context, SemanticModel semanticModel)
{
var diagnosedIssue = false;
foreach (SyntaxNode descendant in method.DescendantNodes())
{
if (descendant is IdentifierNameSyntax identifierName)
{
var identifierText = identifierName.Identifier.ValueText;
if (identifierText == "ContinueWith")
{
if (!HasExecuteSynchronously(identifierName))
{
var memberAccessExpression = identifierName.Parent;
var diagnostic = Diagnostic.Create(Rule, memberAccessExpression.GetLocation(), "Task.ContinueWith");
context.ReportDiagnostic(diagnostic);
diagnosedIssue = true;
}
}
}
}
return(diagnosedIssue);
}
public static BuildServiceProviderValidator CreateAndInitialize(CompilationAnalysisContext context, ConcurrentBag <StartupComputedAnalysis> analyses)
{
if (analyses == null)
{
throw new ArgumentNullException(nameof(analyses));
}
var validator = new BuildServiceProviderValidator();
foreach (var serviceAnalysis in analyses.OfType <ServicesAnalysis>())
{
foreach (var serviceItem in serviceAnalysis.Services)
{
if (serviceItem.UseMethod.Name == "BuildServiceProvider")
{
context.ReportDiagnostic(Diagnostic.Create(
StartupAnalzyer.BuildServiceProviderShouldNotCalledInConfigureServicesMethod,
serviceItem.Operation.Syntax.GetLocation(),
serviceItem.UseMethod.Name,
serviceAnalysis.ConfigureServicesMethod.Name));
}
}
}
return(validator);
}
/// <summary>
/// Uses the supplied <paramref name="compilationEndContext"/> to report any file-parsing-related diagnostics.
/// </summary>
/// <param name="compilationEndContext">A context provided from a compilation end action.</param>
public void ReportAnyParsingDiagnostics(CompilationAnalysisContext compilationEndContext)
{
foreach (Diagnostic diagnostic in ParsingDiagnostics)
{
compilationEndContext.ReportDiagnostic(diagnostic);
}
}
public static void ReportProblems(
CompilationAnalysisContext context,
SemanticModel semanticModel,
IEnumerable <ActivityFunctionDefinition> availableFunctions,
IEnumerable <ActivityFunctionCall> calledFunctions)
{
foreach (var activityInvocation in calledFunctions)
{
var functionDefinition = availableFunctions.Where(x => x.FunctionName == activityInvocation.Name).FirstOrDefault();
if (functionDefinition != null && activityInvocation.ReturnTypeNode != null)
{
TryGetInvocationReturnType(semanticModel, activityInvocation, out ITypeSymbol invocationReturnType);
TryGetDefinitionReturnType(semanticModel, functionDefinition, out ITypeSymbol definitionReturnType);
if (!InputMatchesOrTaskOrCompatibleType(invocationReturnType, definitionReturnType))
{
var invocationTypeName = SyntaxNodeUtils.GetQualifiedTypeName(invocationReturnType);
var functionTypeName = SyntaxNodeUtils.GetQualifiedTypeName(definitionReturnType);
var diagnostic = Diagnostic.Create(Rule, activityInvocation.InvocationExpression.GetLocation(), activityInvocation.Name, functionTypeName, invocationTypeName);
context.ReportDiagnostic(diagnostic);
}
}
}
}
internal static bool RegisterDiagnostic(SyntaxNode method, CompilationAnalysisContext context, SemanticModel semanticModel)
{
var diagnosedIssue = false;
foreach (SyntaxNode descendant in method.DescendantNodes())
{
if (descendant is IdentifierNameSyntax identifierName)
{
var identifierText = identifierName.Identifier.ValueText;
if (identifierText == "GetEnvironmentVariable" || identifierText == "GetEnvironmentVariables" || identifierText == "ExpandEnvironmentVariables")
{
var memberAccessExpression = identifierName.Parent;
var invocationExpression = memberAccessExpression.Parent;
if (SyntaxNodeUtils.TryGetISymbol(semanticModel, memberAccessExpression, out ISymbol memberSymbol))
{
if (memberSymbol.ToString().StartsWith("System.Environment"))
{
var diagnostic = Diagnostic.Create(Rule, invocationExpression.GetLocation(), memberAccessExpression);
context.ReportDiagnostic(diagnostic);
diagnosedIssue = true;
}
}
}
}
}
return(diagnosedIssue);
}
public static void ReportDiagnosticIfNonGenerated(this CompilationAnalysisContext context, Diagnostic diagnostic)
{
if (!diagnostic.Location.SourceTree.IsGenerated())
{
context.ReportDiagnostic(diagnostic);
}
}
internal static bool RegisterDiagnostic(SyntaxNode method, CompilationAnalysisContext context, SemanticModel semanticModel)
{
var diagnosedIssue = false;
foreach (SyntaxNode descendant in method.DescendantNodes())
{
if (descendant is IdentifierNameSyntax identifierName)
{
var typeInfo = SyntaxNodeUtils.GetSyntaxTreeSemanticModel(semanticModel, identifierName).GetTypeInfo(identifierName);
if (typeInfo.Type != null)
{
var type = typeInfo.Type.ToString();
if (IsIOClass(type))
{
var diagnostic = Diagnostic.Create(Rule, identifierName.Identifier.GetLocation(), type);
context.ReportDiagnostic(diagnostic);
diagnosedIssue = true;
}
}
}
}
return(diagnosedIssue);
}
public void HandleCompilation(CompilationAnalysisContext context)
{
if (Volatile.Read(ref this.documentationAnalysisDisabled))
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, Location.None));
}
}
public void CompilationEndAction(CompilationAnalysisContext context)
{
if (_interfacesWithUnsecureMethods.Count == 0 || _secureTypes.Count == 0)
{
// No violating types.
return;
}
// Report diagnostic for violating named types.
foreach (INamedTypeSymbol secureType in _secureTypes)
{
foreach (INamedTypeSymbol unsecureInterface in _interfacesWithUnsecureMethods)
{
if (secureType.AllInterfaces.Contains(unsecureInterface))
{
context.ReportDiagnostic(
Diagnostic.Create(
Rule,
secureType.Locations[0],
secureType.Name,
SecureTypeInterfaceName,
unsecureInterface.Name));
break;
}
}
}
}
public void EndCompilationAction(CompilationAnalysisContext context)
{
foreach (Diagnostic diagnostic in _diagnostics)
{
context.ReportDiagnostic(diagnostic);
}
}
private static void AnalyzeCompilation(CompilationAnalysisContext context)
{
var compilation = context.Compilation;
var allPlugins = compilation.SyntaxTrees
.Select(x => x.GetCompilationUnitRoot())
.SelectMany(x => x.FindSyntax <ClassDeclarationSyntax>())
.Where(x => x.IsPluginClass())
.ToArray();
var plugins = allPlugins.Where(x => x.IsExportIPlugin()).ToArray();
foreach (var p in allPlugins)
{
var guidVaue = p.GetGuidMetadataValue();
if (guidVaue == null)
{
continue; //GUID な Metadata がない場合はスルー
}
// GUID として解釈できない値か、IPlugin で未定義の GUID が指定されてたらアウト
Guid guid;
if (!Guid.TryParse(guidVaue, out guid) ||
plugins.All(x => x.GetGuidMetadataValue().ToUpper() != guidVaue.ToUpper()))
{
context.ReportDiagnostic(Diagnostic.Create(InvalidGuidMetadataRule, p.GetLocation()));
}
}
}
private static void AnalyzeCompilation(CompilationAnalysisContext context)
{
var compilation = context.Compilation;
var plugins = compilation.SyntaxTrees
.Select(x => x.GetCompilationUnitRoot())
.SelectMany(x => x.FindSyntax <ClassDeclarationSyntax>())
.Where(x => x.IsExportIPlugin())
.ToArray();
var dupe = plugins
.GroupBy(x => x.GetGuidMetadataValue(compilation.GetSemanticModel(x.SyntaxTree)))
.Where(x => 1 < x.Count())
.ToArray();
if (!dupe.Any())
{
return;
}
foreach (var group in dupe)
{
foreach (var c in group)
{
var other = group.Except(new[] { c }).ToArray();
context.ReportDiagnostic(Diagnostic.Create(
DuplicateGuidRule,
c.GetLocation(),
string.Join(", ", other.Select(x => x.Identifier))));
}
}
}
private void AnalyzeDbContext(CompilationAnalysisContext context)
{
var visitor = new DbContextSymbolsVisitor();
visitor.Visit(context.Compilation.GlobalNamespace);
var entities = visitor.EntityExtensions.Select(s => s.Name).ToArray();
foreach (var dbContext in visitor.DbContextExtensions)
{
var dbSets = dbContext
.GetMembers()
.OfType <IPropertySymbol>()
.Select(p => p.Type)
.OfType <INamedTypeSymbol>()
.Where(t => t.Name == "DbSet" && t.TypeArguments.Length == 1)
.Select(t => t.TypeArguments.ElementAt(0).Name)
.ToArray();
var missingEntities = entities.Except(dbSets).ToArray();
if (missingEntities.Any())
{
foreach (var location in dbContext.Locations)
{
context.ReportDiagnostic(Diagnostic.Create(DbContextMissingDbSetPropertiesRule, location, new[] { dbContext.Name, string.Join <string>(", ", missingEntities) }));
}
}
}
}
private static void DumpAdditionalFiles(CompilationAnalysisContext context)
{
foreach (AdditionalText additionalFile in context.Options.AdditionalFiles)
{
context.ReportDiagnostic(Diagnostic.Create(diagnostic, Location.None, additionalFile.Path));
}
}
private static void AnalyzeCompilation(CompilationAnalysisContext context)
{
var compilation = context.Compilation;
var plugins = compilation.SyntaxTrees
.Select(x => x.GetCompilationUnitRoot())
.SelectMany(x => x.FindSyntax<ClassDeclarationSyntax>())
.Where(x => x.IsExportIPlugin())
.ToArray();
var dupe = plugins
.GroupBy(x => x.GetGuidMetadataValue())
.Where(x => 1 < x.Count())
.ToArray();
if (!dupe.Any()) return;
foreach (var group in dupe)
{
foreach (var c in group)
{
var other = group.Except(new[] { c }).ToArray();
context.ReportDiagnostic(Diagnostic.Create(
DuplicateGuidRule,
c.GetLocation(),
string.Join(", ", other.Select(x => x.Identifier))));
}
}
}
private void AnalyzeWarningLevel(CompilationAnalysisContext context)
{
if (context.Compilation.Options.WarningLevel < 4)
{
context.ReportDiagnostic(Diagnostic.Create(Rule, Location.None));
}
}
public static bool RegisterDiagnostic(CompilationAnalysisContext context, SyntaxNode method)
{
var diagnosedIssue = false;
if (SyntaxNodeUtils.IsInsideOrchestrationTrigger(method))
{
foreach (SyntaxNode descendant in method.DescendantNodes())
{
if (descendant is ParameterSyntax parameter)
{
var identifierType = parameter.Type;
if (identifierType != null && identifierType.ToString() == "CancellationToken")
{
var diagnostic = Diagnostic.Create(Rule, parameter.GetLocation());
context.ReportDiagnostic(diagnostic);
diagnosedIssue = true;
}
}
}
}
return(diagnosedIssue);
}
public void HandleCompilation(CompilationAnalysisContext context)
{
if (Volatile.Read(ref this.documentationAnalysisDisabled))
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, Location.None));
}
}
private static bool AnalyzeIdentifierTask(SyntaxNode method, CompilationAnalysisContext context, SemanticModel semanticModel)
{
var diagnosedIssue = false;
foreach (SyntaxNode descendant in method.DescendantNodes())
{
if (descendant is IdentifierNameSyntax identifierName)
{
var identifierText = identifierName.Identifier.ValueText;
if (identifierText == "Run" || identifierText == "Factory.StartNew")
{
var memberAccessExpression = identifierName.Parent;
if (SyntaxNodeUtils.TryGetISymbol(semanticModel, memberAccessExpression, out ISymbol memberSymbol))
{
if (memberSymbol.ToString().StartsWith("System.Threading.Tasks.Task"))
{
var diagnostic = Diagnostic.Create(Rule, memberAccessExpression.GetLocation(), memberAccessExpression);
context.ReportDiagnostic(diagnostic);
diagnosedIssue = true;
}
}
}
}
}
return(diagnosedIssue);
}
internal void CompilationEnd(CompilationAnalysisContext context)
{
if (_codeFixProviders == null)
{
// No fixers.
return;
}
if (_codeActionCreateInvocations == null && _codeActionObjectCreations == null)
{
// No registered fixes.
return;
}
// Analyze all fixers that have FixAll support.
// Otherwise, report RS1016 (OverrideGetFixAllProviderRule) to recommend adding FixAll support.
foreach (INamedTypeSymbol fixer in _codeFixProviders)
{
if (OverridesGetFixAllProvider(fixer))
{
AnalyzeFixerWithFixAll(fixer, context);
}
else if (fixer.BaseType != null && fixer.BaseType.Equals(_codeFixProviderSymbol))
{
Diagnostic diagnostic = Diagnostic.Create(OverrideGetFixAllProviderRule, fixer.Locations.First(), fixer.Name);
context.ReportDiagnostic(diagnostic);
}
}
}
private string CheckAttribute(XElement element,
string attributeName,
string defaultValue,
Func <string, bool> isGoodValue,
DiagnosticDescriptor diagnosticDescriptor,
XElement lastFoundElement,
AdditionalText file,
CompilationAnalysisContext context)
{
var attributeValue = element?.Attribute(attributeName);
var value = attributeValue?.Value ?? defaultValue;
var v = value.Trim();
if (isGoodValue(v))
{
return(v);
}
var lineInfo = (IXmlLineInfo)lastFoundElement;
int lineNumber = lastFoundElement != null && lineInfo.HasLineInfo() ? lineInfo.LineNumber : 1;
context.ReportDiagnostic(ExternalDiagnostic.Create(diagnosticDescriptor,
file.Path,
lineNumber,
lastFoundElement.ToStringStartElement()));
return(v);
}
private static bool AnalyzeIdentifierTask(SyntaxNode method, CompilationAnalysisContext context, SemanticModel semanticModel)
{
var diagnosedIssue = false;
foreach (SyntaxNode descendant in method.DescendantNodes())
{
if (descendant is IdentifierNameSyntax identifierName)
{
version = SyntaxNodeUtils.GetDurableVersion(semanticModel);
var identifierText = identifierName.Identifier.ValueText;
if (identifierText == "Delay")
{
var memberAccessExpression = identifierName.Parent;
var memberSymbol = SyntaxNodeUtils.GetSyntaxTreeSemanticModel(semanticModel, memberAccessExpression).GetSymbolInfo(memberAccessExpression).Symbol;
if (memberSymbol != null && memberSymbol.ToString().StartsWith("System.Threading.Tasks.Task"))
{
if (TryGetRuleFromVersion(out DiagnosticDescriptor rule))
{
var expression = GetAwaitOrInvocationExpression(memberAccessExpression);
var diagnostic = Diagnostic.Create(rule, expression.GetLocation(), expression);
context.ReportDiagnostic(diagnostic);
diagnosedIssue = true;
}
}
}
}
}
return(diagnosedIssue);
}
private static bool AnalyzeIdentifierThread(SyntaxNode method, CompilationAnalysisContext context, SemanticModel semanticModel)
{
var diagnosedIssue = false;
foreach (SyntaxNode descendant in method.DescendantNodes())
{
if (descendant is IdentifierNameSyntax identifierName)
{
var identifierText = identifierName.Identifier.ValueText;
if (identifierText == "Start")
{
var memberAccessExpression = identifierName.Parent;
var memberSymbol = SyntaxNodeUtils.GetSyntaxTreeSemanticModel(semanticModel, memberAccessExpression).GetSymbolInfo(memberAccessExpression).Symbol;
if (memberSymbol != null && memberSymbol.ToString().StartsWith("System.Threading.Thread"))
{
var diagnostic = Diagnostic.Create(Rule, memberAccessExpression.GetLocation(), memberAccessExpression);
context.ReportDiagnostic(diagnostic);
diagnosedIssue = true;
}
}
}
}
return(diagnosedIssue);
}
private static void AnalyzeCompilation(CompilationAnalysisContext context)
{
var compilation = context.Compilation;
var allPlugins = compilation.SyntaxTrees
.Select(x => x.GetCompilationUnitRoot())
.SelectMany(x => x.FindSyntax<ClassDeclarationSyntax>())
.Where(x => x.IsPluginClass())
.ToArray();
var plugins = allPlugins.Where(x => x.IsExportIPlugin()).ToArray();
foreach (var p in allPlugins)
{
var semanticModel = compilation.GetSemanticModel(p.SyntaxTree);
var syntax = p.GetGuidMetadataValueSyntax();
if (syntax == null) continue; //GUID な Metadata がない場合はスルー
// GUID として解釈できない値か、IPlugin で未定義の GUID が指定されてたらアウト
var guidMetadata = syntax.GetGuidMetadata(semanticModel);
if (!guidMetadata.HasValue
|| plugins.All(x => x.GetGuidMetadataValueSyntax()?.GetGuidMetadata(compilation.GetSemanticModel(x.SyntaxTree)) != guidMetadata))
{
context.ReportDiagnostic(Diagnostic.Create(InvalidGuidMetadataRule, p.GetLocation()));
}
}
}
private void Analyze(CompilationAnalysisContext context)
{
foreach (var attribute in context.Compilation.Assembly.GetAttributes())
{
if (attribute.AttributeClass.Name != "InternalsVisibleToAttribute" ||
attribute.ConstructorArguments.Length != 1)
{
continue;
}
var parameter = Convert.ToString(attribute.ConstructorArguments[0].Value);
var allowed = false;
foreach (var suffix in AllowedSuffixes)
{
if (parameter.IndexOf(suffix, StringComparison.OrdinalIgnoreCase) != -1)
{
allowed = true;
break;
}
}
if (!allowed)
{
context.ReportDiagnostic(
Diagnostic.Create(Descriptors.AZC0011,
attribute.ApplicationSyntaxReference.GetSyntax().GetLocation()));
}
}
}
private void onCompilation(CompilationAnalysisContext context)
{
if (!context.Options.AdditionalFiles.Any())
{
return;
}
var srcFiles = FileFilter.GetFiles(context.Options.AdditionalFiles).ToList();
if (!srcFiles.Any())
{
return;
}
foreach (IAdditionalTextAnalyzer analyzer in Analyzers)
{
var diagnosticInfo = analyzer.GetDiagnosticInfo(srcFiles, context.CancellationToken);
foreach (var info in diagnosticInfo)
{
var supportedDiagnostic = GetSupportedDiagnosticAttribute(analyzer);
var diagnostic = DiagnosticFactory.Create(supportedDiagnostic.GetDescriptor(), info);
context.ReportDiagnostic(diagnostic);
}
}
}
internal void AnalyzeCompilationEnd(CompilationAnalysisContext context)
{
if (!_hasMemberNamedSymbolDeclaredEvent)
{
return;
}
foreach ((INamedTypeSymbol sourceSymbol, _) in _sourceSymbolsToCheck)
{
var found = false;
foreach (INamedTypeSymbol type in sourceSymbol.GetBaseTypesAndThis())
{
if (_typesWithSymbolDeclaredEventInvoked.ContainsKey(type))
{
found = true;
break;
}
}
if (!found)
{
Diagnostic diagnostic = Diagnostic.Create(SymbolDeclaredEventRule, sourceSymbol.Locations[0], sourceSymbol.Name, _compilationType.Name, SymbolDeclaredEventName);
context.ReportDiagnostic(diagnostic);
}
}
}
private static void Analyze(CompilationAnalysisContext context)
{
if (!Analyze(context.Compilation))
{
context.ReportDiagnostic(Diagnostic.Create(DUR0004_DurianModulesAreValidOnlyInCSharp, Location.None));
}
}
public static void AnalyzeCompilation(
CompilationAnalysisContext ctx
)
{
bool hasAnnotationsReference = ctx.Compilation
.References
.Any(IsTheAnnotationsAssembly);
if (!hasAnnotationsReference)
{
ctx.ReportDiagnostic(
Diagnostic.Create(
Diagnostics.MustReferenceAnnotations,
Location.None
)
);
}
// TODO:
// * How does VS sometimes offer you "Add reference to foo.dll" as
// a fix?
// * Does it look at what other projects in the solution reference
// to get a symbol? That'd be too complicated to implement here.
// * Can we use their fix somehow?
// * Should we open up a GitHub issue for this?
}
public static bool RegisterDiagnostic(SyntaxNode method, CompilationAnalysisContext context, SemanticModel semanticModel)
{
var diagnosedIssue = false;
foreach (SyntaxNode descendant in method.DescendantNodes())
{
if (descendant is IdentifierNameSyntax identifierName)
{
var identifierText = identifierName.Identifier.ValueText;
if (identifierText == "Now" || identifierText == "UtcNow" || identifierText == "Today")
{
var memberAccessExpression = identifierName.Parent;
if (SyntaxNodeUtils.TryGetISymbol(semanticModel, memberAccessExpression, out ISymbol memberSymbol))
{
//Covers both DateTime and DateTimeOffset
if (memberSymbol.ToString().StartsWith("System.DateTime"))
{
var diagnostic = Diagnostic.Create(Rule, memberAccessExpression.GetLocation(), memberAccessExpression);
context.ReportDiagnostic(diagnostic);
diagnosedIssue = true;
}
}
}
}
}
return(diagnosedIssue);
}
public static void ReportDiagnostic(this CompilationAnalysisContext context, DiagnosticDescriptor descriptor, ImmutableDictionary <string, string>?properties, ISymbol symbol, params string[] messageArgs)
{
foreach (var location in symbol.Locations)
{
context.ReportDiagnostic(CreateDiagnostic(descriptor, location, properties, messageArgs));
}
}
public void Evaluate(CompilationAnalysisContext compilationEndContext)
{
Parallel.ForEach(_badNodes, (identifierNameSyntax) =>
{
var diagnostic = DiagnosticFormatter.CreateDiagnostic(Rule, identifierNameSyntax);
compilationEndContext.ReportDiagnostic(diagnostic);
});
}
private void OnCompilation(CompilationAnalysisContext context)
{
// Report the hidden diagnostic on all trees in compilation.
foreach (var tree in context.Compilation.SyntaxTrees)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, tree.GetRoot().GetLocation()));
}
}
private static void OnCompilation(CompilationAnalysisContext context)
{
var diags = OnCompilationAsync(context.Compilation).Result;
foreach (var d in diags)
{
context.ReportDiagnostic(d);
}
}
public void AnalyzeCompilation(CompilationAnalysisContext context)
{
foreach (var item in _fieldDisposedMap)
{
if (!item.Value)
{
context.ReportDiagnostic(item.Key.CreateDiagnostic(Rule));
}
}
}
private static void AnalyzeCompilation(CompilationAnalysisContext context)
{
// Get all the suppressed analyzer diagnostic IDs.
var suppressedAnalyzerDiagnosticIds = GetSuppressedAnalyzerDiagnosticIds(context.Compilation.Options.SpecificDiagnosticOptions);
foreach (var suppressedDiagnosticId in suppressedAnalyzerDiagnosticIds)
{
// For all such suppressed diagnostic IDs, produce a diagnostic.
var diagnostic = Diagnostic.Create(Rule, Location.None, suppressedDiagnosticId);
context.ReportDiagnostic(diagnostic);
}
}
private static void AnalyzeCompilation(CompilationAnalysisContext context)
{
var compilation = context.Compilation;
var isDefined = compilation.SyntaxTrees
.Select(x => x.GetCompilationUnitRoot())
.SelectMany(x => x.DescendantNodes().OfType<SimpleBaseTypeSyntax>())
.Any(x => x.ToString() == "IPlugin" || x.ToString() == "Grabacr07.KanColleViewer.Composition.IPlugin")
;
if (!isDefined)
context.ReportDiagnostic(Diagnostic.Create(RequireIPluginRule, Location.None));
}
private static void AnalyzeCompilation(CompilationAnalysisContext context)
{
INamedTypeSymbol assemblyVersionAttributeSymbol = WellKnownTypes.AssemblyVersionAttribute(context.Compilation);
INamedTypeSymbol assemblyComplianceAttributeSymbol = WellKnownTypes.CLSCompliantAttribute(context.Compilation);
if (assemblyVersionAttributeSymbol == null && assemblyComplianceAttributeSymbol == null)
{
return;
}
bool assemblyVersionAttributeFound = false;
bool assemblyComplianceAttributeFound = false;
// Check all assembly level attributes for the target attribute
foreach (AttributeData attribute in context.Compilation.Assembly.GetAttributes())
{
if (attribute.AttributeClass.Equals(assemblyVersionAttributeSymbol))
{
// Mark the version attribute as found
assemblyVersionAttributeFound = true;
}
else if (attribute.AttributeClass.Equals(assemblyComplianceAttributeSymbol))
{
// Mark the compliance attribute as found
assemblyComplianceAttributeFound = true;
}
}
if (!assemblyVersionAttributeFound && assemblyVersionAttributeSymbol != null)
{
context.ReportDiagnostic(Diagnostic.Create(CA1016Rule, Location.None));
}
if (!assemblyComplianceAttributeFound && assemblyComplianceAttributeSymbol != null)
{
context.ReportDiagnostic(Diagnostic.Create(CA1014Rule, Location.None));
}
}
private void OnCompilationEnd(CompilationAnalysisContext context)
{
lock (_apisToEnsureExist)
{
if (_apisToEnsureExist.Count != 0)
{
// If we have not cleared the list of APIs that must exist then we need to give errors about them
foreach (var missingAPI in _apisToEnsureExist)
{
context.ReportDiagnostic(Diagnostic.Create(s_memberMustExistDiagnostic, Location.None, missingAPI));
}
}
}
}
private static void HandleCompilation(CompilationAnalysisContext context)
{
try
{
SettingsHelper.GetStyleCopSettings(context.Options, DeserializationFailureBehavior.ThrowException, context.CancellationToken);
}
catch (JsonException ex)
{
string details = ex.Message;
string completeDescription = string.Format(Description.ToString(CultureInfo.CurrentCulture), details);
var completeDescriptor = new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.SpecialRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, completeDescription, HelpLink);
context.ReportDiagnostic(Diagnostic.Create(completeDescriptor, Location.None));
}
}
private void AnalizeCompilation(CompilationAnalysisContext context)
{
// Find CS0006: Metadata file '{0}' could not be found
Diagnostic invalidMetadataDiagnostic = context.Compilation
.GetDiagnostics().FirstOrDefault(d => string.Compare(d.Id, "CS0006") == 0);
if (invalidMetadataDiagnostic != null)
{
var argument = invalidMetadataDiagnostic.GetDiagnosticMessageArguments().First().ToString();
if (argument != null && string.Compare(Path.GetExtension(argument), ".dll") == 0)
{
var diagnostic = Diagnostic.Create(_supportedRule, invalidMetadataDiagnostic.Location,
argument, ".dll");
context.ReportDiagnostic(diagnostic);
}
}
}
private static void AnalyzeCompilation(CompilationAnalysisContext context)
{
var compilation = context.Compilation;
var allPlugins = compilation.SyntaxTrees
.Select(x => x.GetCompilationUnitRoot())
.SelectMany(x => x.FindSyntax<ClassDeclarationSyntax>())
.Where(x => x.IsPluginClass())
.ToArray();
var plugins = allPlugins.Where(x => x.IsExportIPlugin()).ToArray();
foreach (var p in allPlugins)
{
var guidVaue = p.GetGuidMetadataValue();
if (guidVaue == null) continue; //GUID な Metadata がない場合はスルー
// GUID として解釈できない値か、IPlugin で未定義の GUID が指定されてたらアウト
Guid guid;
if (!Guid.TryParse(guidVaue, out guid)
|| plugins.All(x => x.GetGuidMetadataValue().ToUpper() != guidVaue.ToUpper()))
context.ReportDiagnostic(Diagnostic.Create(InvalidGuidMetadataRule, p.GetLocation()));
}
}
void Report(CompilationAnalysisContext context, IFieldSymbol field, DiagnosticDescriptor descriptor)
{
context.ReportDiagnostic(Diagnostic.Create(descriptor, field.Locations.FirstOrDefault()));
}
//reports a diagnostics
private static void ReportDiagnostic(CompilationAnalysisContext context, DiagnosticDescriptor rule, Location location, params string[] messageArgs)
{
Diagnostic diagnostic = Diagnostic.Create(rule, location, messageArgs);
context.ReportDiagnostic(diagnostic);
}
private void AnalyzeCompilation(CompilationAnalysisContext context)
{
INamedTypeSymbol assemblyVersionAttributeSymbol = WellKnownTypes.AssemblyVersionAttribute(context.Compilation);
INamedTypeSymbol assemblyComplianceAttributeSymbol = WellKnownTypes.CLSCompliantAttribute(context.Compilation);
if (assemblyVersionAttributeSymbol == null && assemblyComplianceAttributeSymbol == null)
{
return;
}
bool assemblyVersionAttributeFound = false;
bool assemblyComplianceAttributeFound = false;
// Check all assembly level attributes for the target attribute
foreach (AttributeData attribute in context.Compilation.Assembly.GetAttributes())
{
if (attribute.AttributeClass.Equals(assemblyVersionAttributeSymbol))
{
// Mark the version attribute as found
assemblyVersionAttributeFound = true;
}
else if (attribute.AttributeClass.Equals(assemblyComplianceAttributeSymbol))
{
// Mark the compliance attribute as found
assemblyComplianceAttributeFound = true;
}
}
// Check for the case where we do not have the target attribute defined at all in our metadata references. If so, how can they reference it
if (assemblyVersionAttributeSymbol == null)
{
assemblyVersionAttributeFound = false;
}
if (assemblyComplianceAttributeSymbol == null)
{
assemblyComplianceAttributeFound = false;
}
// If there's at least one diagnostic to report, let's report them
if (!assemblyComplianceAttributeFound || !assemblyVersionAttributeFound)
{
if (!assemblyVersionAttributeFound)
{
context.ReportDiagnostic(Diagnostic.Create(CA1016Rule, Location.None));
}
if (!assemblyComplianceAttributeFound)
{
context.ReportDiagnostic(Diagnostic.Create(CA1014Rule, Location.None));
}
}
}
private static void ReportDisposeMethods(ImmutableHashSet<IMethodSymbol> allDisposeMethods, ImmutableHashSet<IMethodSymbol> implementingDisposeMethods,
ImmutableDictionary<INamedTypeSymbol, ImmutableHashSet<IMethodSymbol>> disposeMethodsCalledFromDispose, CompilationAnalysisContext c)
{
foreach (var dispose in allDisposeMethods.Except(implementingDisposeMethods))
{
if (MethodCalledFromDispose(disposeMethodsCalledFromDispose, dispose))
{
continue;
}
foreach (var declaringSyntaxReference in dispose.DeclaringSyntaxReferences)
{
var methodDeclaration =
declaringSyntaxReference.GetSyntax() as MethodDeclarationSyntax;
if (methodDeclaration != null)
{
c.ReportDiagnostic(Diagnostic.Create(Rule, methodDeclaration.Identifier.GetLocation()));
}
}
}
}
private void OnCompilation(CompilationAnalysisContext context)
{
// Report the hidden diagnostic on all trees in compilation.
foreach (var tree in context.Compilation.SyntaxTrees)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, tree.GetRoot().GetLocation()));
}
}
internal void OnCompilationEnd(CompilationAnalysisContext context)
{
List<ApiLine> deletedApiList = GetDeletedApiList();
foreach (ApiLine cur in deletedApiList)
{
LinePositionSpan linePositionSpan = cur.SourceText.Lines.GetLinePositionSpan(cur.Span);
Location location = Location.Create(cur.Path, cur.Span, linePositionSpan);
ImmutableDictionary<string, string> propertyBag = ImmutableDictionary<string, string>.Empty.Add(PublicApiNamePropertyBagKey, cur.Text);
context.ReportDiagnostic(Diagnostic.Create(RemoveDeletedApiRule, location, propertyBag, cur.Text));
}
}
/// <summary>
/// Emits a diagnostic for <paramref name="symbol" /> using the <paramref name="messageArgs" /> to format the
/// diagnostic message.
/// </summary>
/// <param name="context">The context in which the diagnostic should be emitted.</param>
/// <param name="symbol">The symbol node the diagnostic is emitted for.</param>
/// <param name="messageArgs">The arguments for formatting the diagnostic message.</param>
public void Emit(CompilationAnalysisContext context, [NotNull] ISymbol symbol, params object[] messageArgs)
{
context.ReportDiagnostic(CreateDiagnostic(symbol.Locations[0], messageArgs));
}
private void AnalyzeCompilation(CompilationAnalysisContext context)
{
// Get the particular attributes I need to look for.
var companyAttributeSymbol = KnownTypes.CompanyAttribute(context.Compilation);
var copyrightAttributeSymbol = KnownTypes.CopyrightAttribute(context.Compilation);
var descriptionAttributeSymbol = KnownTypes.DescriptionAttribute(context.Compilation);
var titleAttributeSymbol = KnownTypes.TitleAttribute(context.Compilation);
// Assume they are all not found.
Boolean companyAttributeGood = false;
Boolean copyrightAttributeGood = false;
Boolean descriptionAttributeGood = false;
Boolean titleAttributeGood = false;
// Pound through each attribute in the assembly checking that the specific ones
// are present and the parameters are not empty.
foreach (var attribute in context.Compilation.Assembly.GetAttributes())
{
if ((companyAttributeSymbol != null) && (attribute.AttributeClass.Equals(companyAttributeSymbol)))
{
companyAttributeGood = CheckAttributeParameter(attribute);
continue;
}
if ((copyrightAttributeSymbol != null) && (attribute.AttributeClass.Equals(copyrightAttributeSymbol)))
{
copyrightAttributeGood = CheckAttributeParameter(attribute);
continue;
}
if ((descriptionAttributeSymbol != null) && (attribute.AttributeClass.Equals(descriptionAttributeSymbol)))
{
descriptionAttributeGood = CheckAttributeParameter(attribute);
continue;
}
if ((titleAttributeSymbol != null) && (attribute.AttributeClass.Equals(titleAttributeSymbol)))
{
titleAttributeGood = CheckAttributeParameter(attribute);
continue;
}
}
// If any of the assembly wide attributes are missing or empty, trigger a warning.
if (!companyAttributeGood)
{
context.ReportDiagnostic(Diagnostic.Create(companyRule, Location.None));
}
if (!copyrightAttributeGood)
{
context.ReportDiagnostic(Diagnostic.Create(copyrightRule, Location.None));
}
if (!descriptionAttributeGood)
{
context.ReportDiagnostic(Diagnostic.Create(descriptionRule, Location.None));
}
if (!titleAttributeGood)
{
context.ReportDiagnostic(Diagnostic.Create(titleRule, Location.None));
}
}
private void ReportUnwrittenFields(CompilationAnalysisContext context)
{
IEnumerable<IFieldSymbol> fieldsToMark = _candidateReadonlyFields.Except(_writtenFields);
foreach (var field in fieldsToMark)
{
context.ReportDiagnostic(Diagnostic.Create(s_rule, field.Locations[0], field.Name));
}
}
public void HandleCompilation(CompilationAnalysisContext context)
{
var compilation = context.Compilation;
var globalNamespace = compilation.GlobalNamespace;
var ruleDependencyAttributeSymbols = GetRuleDependencyAttributeTypeSymbols(globalNamespace);
// if ANTLR 4 isn't referenced, no need to run this analyzer
if (ruleDependencyAttributeSymbols.Length == 0)
return;
IEnumerable<INamedTypeSymbol> typesToCheck = GetAllTypes(compilation.SourceModule.GlobalNamespace);
var builder = ImmutableArray.CreateBuilder<Tuple<AttributeData, ISymbol>>();
foreach (var type in typesToCheck)
builder.AddRange(GetDependencies(type, ruleDependencyAttributeSymbols));
var dependencies = builder.ToImmutable();
if (dependencies.Length == 0)
return;
var recognizerDependencies = new Dictionary<INamedTypeSymbol, IList<Tuple<AttributeData, ISymbol>>>();
foreach (var dependency in dependencies)
{
if (dependency.Item1.AttributeConstructor == null)
continue;
INamedTypeSymbol recognizerType = GetRecognizerType(dependency.Item1);
if (recognizerType == null)
continue;
IList<Tuple<AttributeData, ISymbol>> list;
if (!recognizerDependencies.TryGetValue(recognizerType, out list))
{
list = new List<Tuple<AttributeData, ISymbol>>();
recognizerDependencies[recognizerType] = list;
}
list.Add(dependency);
}
foreach (var entry in recognizerDependencies)
{
var diagnostics = CheckDependencies((CSharpCompilation)compilation, entry.Value, entry.Key);
foreach (var diagnostic in diagnostics)
context.ReportDiagnostic(diagnostic);
}
}
public void CompilationEndAction(CompilationAnalysisContext context)
{
if (_interfacesWithUnsecureMethods == null || _secureTypes == null)
{
// No violating types.
return;
}
// Report diagnostic for violating named types.
foreach (var secureType in _secureTypes)
{
foreach (var unsecureInterface in _interfacesWithUnsecureMethods)
{
if (secureType.AllInterfaces.Contains(unsecureInterface))
{
var diagnostic = Diagnostic.Create(Rule, secureType.Locations[0], secureType.Name, SecureTypeInterfaceName, unsecureInterface.Name);
context.ReportDiagnostic(diagnostic);
break;
}
}
}
}