本文整理汇总了C#中SonarAnalysisContext.RegisterCompilationStartAction方法的典型用法代码示例。如果您正苦于以下问题:C# SonarAnalysisContext.RegisterCompilationStartAction方法的具体用法?C# SonarAnalysisContext.RegisterCompilationStartAction怎么用?C# SonarAnalysisContext.RegisterCompilationStartAction使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类SonarAnalysisContext
的用法示例。
在下文中一共展示了SonarAnalysisContext.RegisterCompilationStartAction方法的7个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: Initialize
protected sealed override void Initialize(SonarAnalysisContext context)
{
var analysisContext = new ParameterLoadingAnalysisContext(context);
Initialize(analysisContext);
context.RegisterCompilationStartAction(
cac =>
{
ParameterLoader.SetParameterValues(this, cac.Options);
foreach (var compilationStartActions in analysisContext.CompilationStartActions)
{
compilationStartActions(cac);
}
});
}
示例2: Initialize
protected override void Initialize(SonarAnalysisContext context)
{
context.RegisterCompilationStartAction(
compilationStartContext =>
{
var allNamedTypeSymbols = compilationStartContext.Compilation.GlobalNamespace.GetAllNamedTypes();
var allInterfacesWithImplementationsOverridenEquals =
allNamedTypeSymbols
.Where(t => t.AllInterfaces.Any() && HasEqualsOverride(t))
.SelectMany(t => t.AllInterfaces)
.ToImmutableHashSet();
compilationStartContext.RegisterSyntaxNodeActionInNonGenerated(
c =>
{
var binary = (BinaryExpressionSyntax)c.Node;
if (!IsBinaryCandidateForReporting(binary, c.SemanticModel))
{
return;
}
var typeLeft = c.SemanticModel.GetTypeInfo(binary.Left).Type;
var typeRight = c.SemanticModel.GetTypeInfo(binary.Right).Type;
if (typeLeft == null ||
typeRight == null ||
IsAllowedType(typeLeft) ||
IsAllowedType(typeRight))
{
return;
}
if (MightOverrideEquals(typeLeft, allInterfacesWithImplementationsOverridenEquals) ||
MightOverrideEquals(typeRight, allInterfacesWithImplementationsOverridenEquals))
{
c.ReportDiagnostic(Diagnostic.Create(Rule, binary.OperatorToken.GetLocation()));
}
},
SyntaxKind.EqualsExpression,
SyntaxKind.NotEqualsExpression);
});
}
示例3: Initialize
protected override void Initialize(SonarAnalysisContext context)
{
context.RegisterCompilationStartAction(analysisContext =>
{
var fieldsByNamedType = MultiValueDictionary<INamedTypeSymbol, IFieldSymbol>.Create<HashSet<IFieldSymbol>>();
var fieldsAssigned = ImmutableHashSet<IFieldSymbol>.Empty;
analysisContext.RegisterSymbolAction(c =>
{
var namedTypeSymbol = (INamedTypeSymbol)c.Symbol;
if (!namedTypeSymbol.IsClass() ||
namedTypeSymbol.Implements(KnownType.System_IDisposable))
{
return;
}
var disposableFields = namedTypeSymbol.GetMembers()
.OfType<IFieldSymbol>()
.Where(IsNonStaticNonPublicDisposableField)
.ToImmutableHashSet();
fieldsByNamedType.AddRangeWithKey(namedTypeSymbol, disposableFields);
}, SymbolKind.NamedType);
analysisContext.RegisterSyntaxNodeAction(c =>
{
var assignment = (AssignmentExpressionSyntax)c.Node;
var expression = assignment.Right;
var fieldSymbol = c.SemanticModel.GetSymbolInfo(assignment.Left).Symbol as IFieldSymbol;
fieldsAssigned = AddFieldIfNeeded(fieldSymbol, expression, fieldsAssigned);
}, SyntaxKind.SimpleAssignmentExpression);
analysisContext.RegisterSyntaxNodeAction(c =>
{
var field = (FieldDeclarationSyntax)c.Node;
foreach (var variableDeclaratorSyntax in field.Declaration.Variables
.Where(declaratorSyntax => declaratorSyntax.Initializer != null))
{
var fieldSymbol = c.SemanticModel.GetDeclaredSymbol(variableDeclaratorSyntax) as IFieldSymbol;
fieldsAssigned = AddFieldIfNeeded(fieldSymbol, variableDeclaratorSyntax.Initializer.Value,
fieldsAssigned);
}
}, SyntaxKind.FieldDeclaration);
analysisContext.RegisterCompilationEndAction(c =>
{
foreach (var kv in fieldsByNamedType)
{
foreach (var classSyntax in kv.Key.DeclaringSyntaxReferences
.Select(declaringSyntaxReference => declaringSyntaxReference.GetSyntax())
.OfType<ClassDeclarationSyntax>())
{
var assignedFields = kv.Value.Intersect(fieldsAssigned).ToList();
if (!assignedFields.Any())
{
continue;
}
var variableNames = string.Join(", ",
assignedFields.Select(symbol => $"\"{symbol.Name}\"").OrderBy(s => s));
c.ReportDiagnosticIfNonGenerated(
Diagnostic.Create(Rule, classSyntax.Identifier.GetLocation(), variableNames),
c.Compilation);
}
}
});
});
}
示例4: Initialize
protected override void Initialize(SonarAnalysisContext context)
{
context.RegisterCompilationStartAction(
compilationStartContext =>
{
var allNamedTypeSymbols = compilationStartContext.Compilation.GlobalNamespace.GetAllNamedTypes();
var typeInterfaceMappings = allNamedTypeSymbols.Select(type =>
new
{
Type = type.OriginalDefinition,
Interfaces = type.OriginalDefinition.AllInterfaces.Select(i => i.OriginalDefinition)
});
var interfaceImplementerMappings = new Dictionary<INamedTypeSymbol, HashSet<INamedTypeSymbol>>();
foreach (var typeInterfaceMapping in typeInterfaceMappings)
{
if (typeInterfaceMapping.Type.IsInterface())
{
if (!interfaceImplementerMappings.ContainsKey(typeInterfaceMapping.Type))
{
interfaceImplementerMappings.Add(typeInterfaceMapping.Type, new HashSet<INamedTypeSymbol>());
}
interfaceImplementerMappings[typeInterfaceMapping.Type].Add(typeInterfaceMapping.Type);
}
foreach (var @interface in typeInterfaceMapping.Interfaces)
{
if (!interfaceImplementerMappings.ContainsKey(@interface))
{
interfaceImplementerMappings.Add(@interface, new HashSet<INamedTypeSymbol>());
}
interfaceImplementerMappings[@interface].Add(typeInterfaceMapping.Type);
}
}
compilationStartContext.RegisterSyntaxNodeActionInNonGenerated(
c =>
{
var cast = (CastExpressionSyntax)c.Node;
var interfaceType = c.SemanticModel.GetTypeInfo(cast.Type).Type as INamedTypeSymbol;
var expressionType = c.SemanticModel.GetTypeInfo(cast.Expression).Type as INamedTypeSymbol;
CheckTypesForInvalidCast(interfaceType, expressionType, interfaceImplementerMappings,
cast.Type.GetLocation(), c);
},
SyntaxKind.CastExpression);
compilationStartContext.RegisterSyntaxNodeAction(
c =>
{
var cast = (BinaryExpressionSyntax)c.Node;
var interfaceType = c.SemanticModel.GetTypeInfo(cast.Right).Type as INamedTypeSymbol;
var expressionType = c.SemanticModel.GetTypeInfo(cast.Left).Type as INamedTypeSymbol;
CheckTypesForInvalidCast(interfaceType, expressionType, interfaceImplementerMappings,
cast.Right.GetLocation(), c);
},
SyntaxKind.AsExpression,
SyntaxKind.IsExpression);
});
context.RegisterExplodedGraphBasedAnalysis((e, c) => CheckEmptyNullableCast(e, c));
}
示例5: Initialize
protected override void Initialize(SonarAnalysisContext context)
{
context.RegisterCompilationStartAction(
analysisContext =>
{
var disposeMethod = GetDisposeMethod(analysisContext.Compilation);
if (disposeMethod == null)
{
return;
}
var disposeMethodsCalledFromDispose = MultiValueDictionary<INamedTypeSymbol, IMethodSymbol>.Create<HashSet<IMethodSymbol>>();
var implementingDisposeMethods = ImmutableHashSet<IMethodSymbol>.Empty;
var allDisposeMethods = ImmutableHashSet<IMethodSymbol>.Empty;
analysisContext.RegisterSymbolAction(c =>
CollectDisposeMethods(c, disposeMethod, ref allDisposeMethods, ref implementingDisposeMethods),
SymbolKind.Method);
analysisContext.RegisterCodeBlockStartAction<SyntaxKind>(
cbc =>
{
var methodDeclaration = cbc.CodeBlock as MethodDeclarationSyntax;
if (methodDeclaration == null ||
methodDeclaration.Identifier.ValueText != DisposeMethodName)
{
return;
}
var declaredMethodSymbol = cbc.SemanticModel.GetDeclaredSymbol(methodDeclaration);
if (declaredMethodSymbol == null ||
!MethodIsDisposeImplementation(declaredMethodSymbol, disposeMethod))
{
return;
}
var disposableType = declaredMethodSymbol.ContainingType;
cbc.RegisterSyntaxNodeAction(
c => CollectDisposeMethodsCalledFromDispose((InvocationExpressionSyntax) c.Node,
c.SemanticModel, disposableType, disposeMethodsCalledFromDispose),
SyntaxKind.InvocationExpression);
});
analysisContext.RegisterCompilationEndAction(
c =>
ReportDisposeMethods(allDisposeMethods, implementingDisposeMethods,
disposeMethodsCalledFromDispose, c));
});
}
示例6: Initialize
protected override void Initialize(SonarAnalysisContext context)
{
context.RegisterCompilationStartAction(analysisContext =>
{
var candidateFields = ImmutableHashSet<IFieldSymbol>.Empty;
var assignedAsReadonly = ImmutableHashSet<IFieldSymbol>.Empty;
var nonCandidateFields = ImmutableHashSet<IFieldSymbol>.Empty;
analysisContext.RegisterSyntaxNodeAction(c =>
{
var fieldDeclaration = (FieldDeclarationSyntax) c.Node;
foreach (var field in fieldDeclaration.Declaration.Variables
.Select(variableDeclaratorSyntax => new
{
Syntax = variableDeclaratorSyntax,
Symbol = c.SemanticModel.GetDeclaredSymbol(variableDeclaratorSyntax) as IFieldSymbol
})
.Where(f => f.Symbol != null)
.Where(f => FieldIsRelevant(f.Symbol)))
{
candidateFields = candidateFields.Add(field.Symbol);
if (field.Syntax.Initializer != null)
{
assignedAsReadonly = assignedAsReadonly.Add(field.Symbol);
}
}
}, SyntaxKind.FieldDeclaration);
analysisContext.RegisterSyntaxNodeAction(
c =>
{
var assignment = (AssignmentExpressionSyntax) c.Node;
var expression = assignment.Left;
ProcessExpressionChange(expression, c.SemanticModel, ref nonCandidateFields, ref assignedAsReadonly);
},
SyntaxKind.SimpleAssignmentExpression,
SyntaxKind.AddAssignmentExpression,
SyntaxKind.SubtractAssignmentExpression,
SyntaxKind.MultiplyAssignmentExpression,
SyntaxKind.DivideAssignmentExpression,
SyntaxKind.ModuloAssignmentExpression,
SyntaxKind.AndAssignmentExpression,
SyntaxKind.ExclusiveOrAssignmentExpression,
SyntaxKind.OrAssignmentExpression,
SyntaxKind.LeftShiftAssignmentExpression,
SyntaxKind.RightShiftAssignmentExpression);
analysisContext.RegisterSyntaxNodeAction(
c =>
{
var unary = (PrefixUnaryExpressionSyntax)c.Node;
var expression = unary.Operand;
ProcessExpressionChange(expression, c.SemanticModel, ref nonCandidateFields, ref assignedAsReadonly);
},
SyntaxKind.PreDecrementExpression,
SyntaxKind.PreIncrementExpression);
analysisContext.RegisterSyntaxNodeAction(
c =>
{
var unary = (PostfixUnaryExpressionSyntax)c.Node;
var expression = unary.Operand;
ProcessExpressionChange(expression, c.SemanticModel, ref nonCandidateFields, ref assignedAsReadonly);
},
SyntaxKind.PostDecrementExpression,
SyntaxKind.PostIncrementExpression);
analysisContext.RegisterSyntaxNodeAction(c =>
{
var argument = (ArgumentSyntax) c.Node;
if (argument.RefOrOutKeyword.IsKind(SyntaxKind.None))
{
return;
}
var fieldSymbol = c.SemanticModel.GetSymbolInfo(argument.Expression).Symbol as IFieldSymbol;
if (FieldIsRelevant(fieldSymbol))
{
nonCandidateFields = nonCandidateFields.Add(fieldSymbol);
}
}, SyntaxKind.Argument);
analysisContext.RegisterCompilationEndAction(c =>
{
var fields = candidateFields.Except(nonCandidateFields);
fields = fields.Intersect(assignedAsReadonly);
foreach (var field in fields)
{
var declarationReference = field.DeclaringSyntaxReferences.FirstOrDefault();
var fieldSyntax = declarationReference?.GetSyntax() as VariableDeclaratorSyntax;
if (fieldSyntax == null)
{
continue;
}
//.........这里部分代码省略.........
示例7: Initialize
protected override void Initialize(SonarAnalysisContext context)
{
context.RegisterCompilationStartAction(analysisContext =>
{
analysisContext.RegisterSyntaxNodeAction(
c =>
{
var methodDeclaration = c.Node as MethodDeclarationSyntax;
var classDeclaration = c.Node as ClassDeclarationSyntax;
if (methodDeclaration != null &&
!IsMethodCandidate(methodDeclaration, c.SemanticModel))
{
return;
}
var declarationSymbol = c.SemanticModel.GetDeclaredSymbol(c.Node);
if (declarationSymbol == null)
{
return;
}
var helper = GetTypeParameterHelper(methodDeclaration, classDeclaration);
if (helper.TypeParameterList == null || helper.TypeParameterList.Parameters.Count == 0)
{
return;
}
var declarations = declarationSymbol.DeclaringSyntaxReferences
.Select(reference => reference.GetSyntax());
var usedTypeParameters = GetUsedTypeParameters(declarations, c, analysisContext.Compilation);
foreach (var typeParameter in helper.TypeParameterList.Parameters
.Select(typeParameter => typeParameter.Identifier.Text)
.Where(typeParameter => !usedTypeParameters.Contains(typeParameter)))
{
c.ReportDiagnostic(Diagnostic.Create(Rule,
helper.TypeParameterList.Parameters.First(tp => tp.Identifier.Text == typeParameter)
.GetLocation(),
typeParameter, helper.ContainerSyntaxTypeName));
}
},
SyntaxKind.MethodDeclaration,
SyntaxKind.ClassDeclaration);
});
}