public static CSharpSyntaxNode Replace(TypeNameReplacementData[] replacedTypeNameArray, CSharpSyntaxNode syntaxNode)
{
var typeNodes = syntaxNode.DescendantNodes()
.OfType<TypeSyntax>()
.Where(f => replacedTypeNameArray.Any(r => r.OldTypeName == f.ToString()));
return syntaxNode.ReplaceNodes(typeNodes, (n1, n2) => {
var name = n1.ToString();
var newName = replacedTypeNameArray.First(f => f.OldTypeName == name).NewTypeName;
var newType = SyntaxFactory.ParseTypeName(newName);
return newType;
});
}
private SyntaxList <StatementSyntax> InsertRequiredDeclarations(
SyntaxList <StatementSyntax> convertedStatements, CSharpSyntaxNode originaNode)
{
var descendantNodes = originaNode.DescendantNodes().ToList();
var declarationExpressions = descendantNodes.OfType <DeclarationExpressionSyntax>()
.Where(e => !e.Parent.IsKind(CSSyntaxKind.ForEachVariableStatement)) //Handled inline for tuple loop
.ToList();
var isPatternExpressions = descendantNodes.OfType <IsPatternExpressionSyntax>().ToList();
if (declarationExpressions.Any() || isPatternExpressions.Any())
{
convertedStatements = convertedStatements.Insert(0, ConvertToDeclarationStatement(declarationExpressions, isPatternExpressions));
}
return(convertedStatements);
}
public static CSharpSyntaxNode Replace(TypeNameReplacementData[] replacedTypeNameArray, CSharpSyntaxNode syntaxNode)
{
var typeNodes = syntaxNode.DescendantNodes()
.OfType <TypeSyntax>()
.Where(f => replacedTypeNameArray.Any(r => r.OldTypeName == f.ToString()));
return(syntaxNode.ReplaceNodes(typeNodes, (n1, n2) =>
{
var name = n1.ToString();
var newName = replacedTypeNameArray.First(f => f.OldTypeName == name).NewTypeName;
var newType = SyntaxFactory.ParseTypeName(newName);
return newType;
}));
}
private static void CheckForRedundantJumps(CSharpSyntaxNode node, SyntaxNodeAnalysisContext context)
{
if (!CSharpControlFlowGraph.TryGet(node, context.SemanticModel, out var cfg))
{
return;
}
var yieldStatementCount = node.DescendantNodes().OfType <YieldStatementSyntax>().Count();
var removableJumps = cfg.Blocks
.OfType <JumpBlock>()
.Where(jumpBlock => IsJumpRemovable(jumpBlock, yieldStatementCount));
foreach (var jumpBlock in removableJumps)
{
context.ReportDiagnosticWhenActive(Diagnostic.Create(rule, jumpBlock.JumpNode.GetLocation()));
}
}
private static void CheckForDeadStores(CSharpSyntaxNode node, ISymbol declaration, SyntaxNodeAnalysisContext context)
{
if (declaration == null ||
node == null ||
// Currently the tuple expressions are not supported and this is known to cause false positives.
// Please check:
// - community feedback: https://github.com/SonarSource/sonar-dotnet/issues/3094
// - implementation ticket: https://github.com/SonarSource/sonar-dotnet/issues/2933
node.DescendantNodes().AnyOfKind(SyntaxKindEx.TupleExpression) ||
!CSharpControlFlowGraph.TryGet(node, context.SemanticModel, out var cfg))
{
return;
}
var lva = CSharpLiveVariableAnalysis.Analyze(cfg, declaration, context.SemanticModel);
foreach (var block in cfg.Blocks)
{
CheckCfgBlockForDeadStores(block, lva.GetLiveOut(block), lva.CapturedVariables, node, declaration, context);
}
}
private List <SyntaxTrivia> UpdateParamTagsInLeadingTrivia(CSharpSyntaxNode node, ISymbol declarationSymbol, SignatureChange updatedSignature)
{
if (!node.HasLeadingTrivia)
{
return(null);
}
var paramNodes = node
.DescendantNodes(descendIntoTrivia: true)
.OfType <XmlElementSyntax>()
.Where(e => e.StartTag.Name.ToString() == DocumentationCommentXmlNames.ParameterElementName);
var permutedParamNodes = VerifyAndPermuteParamNodes(paramNodes, declarationSymbol, updatedSignature);
if (permutedParamNodes == null)
{
return(null);
}
return(GetPermutedTrivia(node, permutedParamNodes));
}
public static IEnumerable <T> Descendants <T>(this CSharpSyntaxNode node) where T : CSharpSyntaxNode
{
return(node.DescendantNodes().OfType <T>());
}
private IEnumerable <MethodDeclarationSyntax> FindMethods(CSharpSyntaxNode node)
{
return(node.DescendantNodes()
.OfType <MethodDeclarationSyntax>());
}
