protected SyntaxList<ExpressionSyntax> RewritePostfixUnarys(SyntaxList<ExpressionSyntax> nodes)
{
if (nodes.Count == 0)
return nodes;
return Syntax.List (nodes.Select (RewritePostfixUnarys));
}
public CodeActionEdit GetEdit(CancellationToken cancellationToken = new CancellationToken())
{
var newReturnType = Syntax.ParseTypeName("HttpResponseMessage").WithTrailingTrivia(Syntax.Space);
var exp = Syntax.ParseExpression("new HttpResponseMessage(HttpStatusCode.Created)").WithLeadingTrivia(Syntax.Space);
var returnStatement = Syntax.ReturnStatement(Syntax.Token(SyntaxKind.ReturnKeyword), exp ,Syntax.Token(SyntaxKind.SemicolonToken));
var oldBody = _method.Body;
var statements = oldBody.Statements.Where(x => x.GetType() != typeof (ReturnStatementSyntax)).ToList();
var syntaxListStatements = new SyntaxList<StatementSyntax>();
syntaxListStatements = statements.Aggregate(syntaxListStatements, (current, syntaxListStatement) => current.Add(syntaxListStatement));
syntaxListStatements = syntaxListStatements.Add(returnStatement);
var newBody = Syntax.Block(Syntax.Token(SyntaxKind.OpenBraceToken), syntaxListStatements, Syntax.Token(SyntaxKind.CloseBraceToken));
var newmethod = Syntax.MethodDeclaration(_method.AttributeLists, _method.Modifiers, newReturnType,
_method.ExplicitInterfaceSpecifier, _method.Identifier,
_method.TypeParameterList, _method.ParameterList,
_method.ConstraintClauses, newBody);
var oldRoot = _document.GetSyntaxRoot(cancellationToken);
var newRoot = oldRoot.ReplaceNode(_method,newmethod);
var newDoc = _document.UpdateSyntaxRoot(newRoot.Format(FormattingOptions.GetDefaultOptions()).GetFormattedRoot());
return new CodeActionEdit(newDoc);
}
/// <summary>
/// Initializes a new instance of the <see cref="UvssInvalidSelectorPartSyntax"/> class.
/// </summary>
internal UvssInvalidSelectorPartSyntax(
SyntaxList<SyntaxToken> components)
: base(SyntaxKind.InvalidSelectorPart)
{
this.Components = components;
ChangeParent(components.Node);
SlotCount = 1;
UpdateIsMissing();
}
/// <summary>
/// Initializes a new instance of the <see cref="UvssSelectorSyntax"/> class.
/// </summary>
internal UvssSelectorSyntax(
SyntaxList<SyntaxNode> components)
: base(SyntaxKind.Selector)
{
this.Components = components;
ChangeParent(components.Node);
SlotCount = 1;
UpdateIsMissing();
}
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
node = (ClassDeclarationSyntax)base.VisitClassDeclaration(node);
MethodDeclarationSyntax prector = Syntax.MethodDeclaration(Syntax.PredefinedType(Syntax.Token(SyntaxKind.VoidKeyword)), ".prector");
List<StatementSyntax> Initializers = new List<StatementSyntax>();
foreach (MemberDeclarationSyntax member in node.Members)
{
if (member.Kind == SyntaxKind.FieldDeclaration)
{
FieldDeclarationSyntax fds = (FieldDeclarationSyntax)member;
foreach (VariableDeclaratorSyntax vds in fds.Declaration.Variables)
{
if (vds.Initializer != null)
{
Initializers.Add(Syntax.ExpressionStatement(Syntax.BinaryExpression(SyntaxKind.AssignExpression, Syntax.IdentifierName(vds.Identifier), vds.Initializer.Value)));
}
}
}
}
if (Initializers.Count == 0)
return node;
int constructors = node.Members.Count((m) => (m is ConstructorDeclarationSyntax));
prector = prector.AddBodyStatements(Initializers.ToArray());
node = node.AddMembers(prector);
if (constructors == 0)
{
ConstructorDeclarationSyntax ctor = Syntax.ConstructorDeclaration(node.Identifier);
ctor = ctor.AddBodyStatements(Syntax.ExpressionStatement(Syntax.InvocationExpression(Syntax.IdentifierName(".prector"))));
ctor = ctor.AddModifiers(Syntax.Token(SyntaxKind.PublicKeyword));
return node.AddMembers(ctor);
}
SyntaxList<MemberDeclarationSyntax> newMembers = new SyntaxList<MemberDeclarationSyntax>();
foreach (MemberDeclarationSyntax member in node.Members)
{
if (member.Kind == SyntaxKind.ConstructorDeclaration)
{
newMembers = newMembers.Add((MemberDeclarationSyntax)ConstructorPrefixerDeclaration((ConstructorDeclarationSyntax)member));
}
else
{
newMembers = newMembers.Add(member);
}
}
return node.WithMembers(newMembers);
}
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
node = (ClassDeclarationSyntax)base.VisitClassDeclaration(node);
SyntaxList<MemberDeclarationSyntax> newMembers = new SyntaxList<MemberDeclarationSyntax>();
foreach (MemberDeclarationSyntax member in node.Members)
{
if (member.Kind == SyntaxKind.PropertyDeclaration)
{
PropertyDeclarationSyntax prop = (PropertyDeclarationSyntax)member;
SyntaxList<AccessorDeclarationSyntax> newAccessors = new SyntaxList<AccessorDeclarationSyntax>();
bool implementfield = false;
foreach (AccessorDeclarationSyntax accessor in prop.AccessorList.Accessors)
{
if (accessor.Body == null)
{
switch (accessor.Kind)
{
case SyntaxKind.GetAccessorDeclaration:
implementfield = true;
newAccessors = newAccessors.Add(accessor.WithBody(Syntax.Block(Syntax.ReturnStatement(Syntax.IdentifierName("_" + prop.Identifier.ValueText)))));
break;
case SyntaxKind.SetAccessorDeclaration:
implementfield = true;
newAccessors = newAccessors.Add(accessor.WithBody(Syntax.Block(Syntax.ExpressionStatement(Syntax.BinaryExpression(SyntaxKind.AssignExpression, Syntax.IdentifierName("_" + prop.Identifier.ValueText), Syntax.IdentifierName("value"))))));
break;
default:
newAccessors = newAccessors.Add(accessor);
break;
}
}
else
{
newAccessors = newAccessors.Add(accessor);
}
}
if (implementfield)
{
SeparatedSyntaxList<VariableDeclaratorSyntax> variables = new SeparatedSyntaxList<VariableDeclaratorSyntax>();
variables = variables.Add(Syntax.VariableDeclarator("_" + prop.Identifier.ValueText));
newMembers = newMembers.Add(Syntax.FieldDeclaration(Syntax.VariableDeclaration(prop.Type, variables)));
}
newMembers = newMembers.Add(prop.WithAccessorList(prop.AccessorList.WithAccessors(newAccessors)));
}
else
{
newMembers = newMembers.Add(member);
}
}
return node.WithMembers(newMembers);
}
/// <summary>
/// Initializes a new instance of the <see cref="UvssDocumentSyntax"/> class.
/// </summary>
internal UvssDocumentSyntax(
SyntaxList<SyntaxNode> content,
SyntaxToken endOfFileToken)
: base(SyntaxKind.Document)
{
this.Content = content;
ChangeParent(content.Node);
this.EndOfFileToken = endOfFileToken;
ChangeParent(endOfFileToken);
SlotCount = 2;
UpdateIsMissing();
}
public static bool AreEquivalent(SyntaxList<SyntaxNode> nodeList1, SyntaxList<SyntaxNode> nodeList2)
{
if (nodeList1.Count != nodeList2.Count)
{
return false;
}
for (var i = 0; i < nodeList1.Count; i++)
{
if (!SyntaxFactory.AreEquivalent(nodeList1[i], nodeList2[i]))
{
return false;
}
}
return true;
}
/// <summary>
/// Initializes a new instance of the <see cref="UvssBlockSyntax"/> class.
/// </summary>
internal UvssBlockSyntax(
SyntaxToken openCurlyBraceToken,
SyntaxList<SyntaxNode> content,
SyntaxToken closeCurlyBraceToken)
: base(SyntaxKind.Block)
{
this.OpenCurlyBraceToken = openCurlyBraceToken;
ChangeParent(openCurlyBraceToken);
this.Content = content;
ChangeParent(content.Node);
this.CloseCurlyBraceToken = closeCurlyBraceToken;
ChangeParent(closeCurlyBraceToken);
SlotCount = 3;
UpdateIsMissing();
}
public static bool AreEquivalent(SyntaxList<SyntaxNode> nodeList1, SyntaxList<SyntaxNode> nodeList2,
Func<SyntaxNode, SyntaxNode, bool> nodeComparator)
{
if (nodeList1.Count != nodeList2.Count)
{
return false;
}
for (var i = 0; i < nodeList1.Count; i++)
{
if (!AreEquivalent(nodeList1[i], nodeList2[i], nodeComparator))
{
return false;
}
}
return true;
}
/// <summary>
/// Initializes a new instance of the <see cref="UvssSelectorPartSyntax"/> class.
/// </summary>
internal UvssSelectorPartSyntax(
UvssSelectorPartTypeSyntax selectedType,
UvssSelectorPartNameSyntax selectedName,
SyntaxList<UvssSelectorPartClassSyntax> selectedClasses,
UvssPseudoClassSyntax pseudoClass)
: base(SyntaxKind.SelectorPart)
{
this.SelectedType = selectedType;
ChangeParent(selectedType);
this.SelectedName = selectedName;
ChangeParent(selectedName);
this.SelectedClasses = selectedClasses;
ChangeParent(selectedClasses.Node);
this.PseudoClass = pseudoClass;
ChangeParent(pseudoClass);
SlotCount = 4;
UpdateIsMissing();
}
private void WriteGlobalNodes(SyntaxList<UsingDirectiveSyntax> usings, SyntaxList<ExternAliasDirectiveSyntax> externs, SyntaxList<MemberDeclarationSyntax> members, SyntaxList<AttributeListSyntax> attributeLists)
{
string lastUsingGroup = null;
foreach (var @using in usings)
{
string usingGroup;
var name = @using.Name;
while (name.SyntaxKind == SyntaxKind.QualifiedName)
{
name = ((QualifiedNameSyntax)name).Left;
}
if (name.SyntaxKind == SyntaxKind.IdentifierName)
usingGroup = ((IdentifierNameSyntax)name).Identifier;
else
usingGroup = null;
if (lastUsingGroup != null && usingGroup != lastUsingGroup)
_writer.WriteLine(_writer.Configuration.BlankLines.BetweenDifferentUsingGroups);
@using.Accept(this);
lastUsingGroup = usingGroup;
}
foreach (var @extern in externs)
{
@extern.Accept(this);
}
if (attributeLists != null && attributeLists.Count > 0)
{
if (usings.Count > 0 || externs.Count > 0)
_writer.WriteLine();
foreach (var attribute in attributeLists)
{
_writer.WriteIndent();
attribute.Accept(this);
_writer.WriteLine();
}
}
int newlines;
if (
usings.Count > 0 ||
externs.Count > 0 ||
(attributeLists != null && attributeLists.Count > 0)
)
newlines = _writer.Configuration.BlankLines.AfterUsingList;
else
newlines = 0;
if (members.Count > 0)
{
for (int i = 0; i < members.Count; i++)
{
var member = members[i];
if (i > 0 || newlines > 0)
{
if (member.SyntaxKind == SyntaxKind.NamespaceDeclaration)
newlines = Math.Max(newlines, _writer.Configuration.BlankLines.AroundNamespace);
else if (member is BaseTypeDeclarationSyntax)
newlines = Math.Max(newlines, _writer.Configuration.BlankLines.AroundType);
else
newlines = Math.Max(newlines, 1);
_writer.WriteLine(newlines);
}
member.Accept(this);
if (member.SyntaxKind == SyntaxKind.NamespaceDeclaration)
newlines = _writer.Configuration.BlankLines.AroundNamespace;
else if (member is BaseTypeDeclarationSyntax)
newlines = _writer.Configuration.BlankLines.AroundType;
else
newlines = 1;
}
}
}
static SyntaxList<StatementSyntax> GenerateNewTrueStatement(SyntaxList<StatementSyntax> falseStatements)
{
if (falseStatements.Count == 1)
{
var stmt = falseStatements.First();
if (stmt.GetLeadingTrivia().All(triva => triva.IsKind(SyntaxKind.WhitespaceTrivia)))
return new SyntaxList<StatementSyntax>().Add(stmt);
}
return falseStatements;
}
public static bool TryGetContainingList(TypeParameterConstraintClauseSyntax constraintClause, out SyntaxList <TypeParameterConstraintClauseSyntax> constraintClauses)
{
SyntaxNode parent = constraintClause.Parent;
switch (parent?.Kind())
{
case SyntaxKind.ClassDeclaration:
{
constraintClauses = ((ClassDeclarationSyntax)parent).ConstraintClauses;
return(true);
}
case SyntaxKind.DelegateDeclaration:
{
constraintClauses = ((DelegateDeclarationSyntax)parent).ConstraintClauses;
return(true);
}
case SyntaxKind.InterfaceDeclaration:
{
constraintClauses = ((InterfaceDeclarationSyntax)parent).ConstraintClauses;
return(true);
}
case SyntaxKind.LocalFunctionStatement:
{
constraintClauses = ((LocalFunctionStatementSyntax)parent).ConstraintClauses;
return(true);
}
case SyntaxKind.MethodDeclaration:
{
constraintClauses = ((MethodDeclarationSyntax)parent).ConstraintClauses;
return(true);
}
case SyntaxKind.StructDeclaration:
{
constraintClauses = ((StructDeclarationSyntax)parent).ConstraintClauses;
return(true);
}
}
constraintClauses = default(SyntaxList <TypeParameterConstraintClauseSyntax>);
return(false);
}
public static SyntaxNode RemoveConstraintClauses(SyntaxNode node)
{
switch (node.Kind())
{
case SyntaxKind.ClassDeclaration:
{
var classDeclaration = (ClassDeclarationSyntax)node;
SyntaxList <TypeParameterConstraintClauseSyntax> constraintClauses = classDeclaration.ConstraintClauses;
if (!constraintClauses.Any())
{
break;
}
TypeParameterConstraintClauseSyntax first = constraintClauses.First();
SyntaxToken token = first.WhereKeyword.GetPreviousToken();
SyntaxTriviaList trivia = token.TrailingTrivia.EmptyIfWhitespace()
.AddRange(first.GetLeadingTrivia().EmptyIfWhitespace())
.AddRange(constraintClauses.Last().GetTrailingTrivia());
return(classDeclaration
.ReplaceToken(token, token.WithTrailingTrivia(trivia))
.WithConstraintClauses(default(SyntaxList <TypeParameterConstraintClauseSyntax>)));
}
case SyntaxKind.InterfaceDeclaration:
{
var interfaceDeclaration = (InterfaceDeclarationSyntax)node;
SyntaxList <TypeParameterConstraintClauseSyntax> constraintClauses = interfaceDeclaration.ConstraintClauses;
if (!constraintClauses.Any())
{
break;
}
TypeParameterConstraintClauseSyntax first = constraintClauses.First();
SyntaxToken token = first.WhereKeyword.GetPreviousToken();
SyntaxTriviaList trivia = token.TrailingTrivia.EmptyIfWhitespace()
.AddRange(first.GetLeadingTrivia().EmptyIfWhitespace())
.AddRange(constraintClauses.Last().GetTrailingTrivia());
return(interfaceDeclaration
.ReplaceToken(token, token.WithTrailingTrivia(trivia))
.WithConstraintClauses(default(SyntaxList <TypeParameterConstraintClauseSyntax>)));
}
case SyntaxKind.StructDeclaration:
{
var structDeclaration = (StructDeclarationSyntax)node;
SyntaxList <TypeParameterConstraintClauseSyntax> constraintClauses = structDeclaration.ConstraintClauses;
if (!constraintClauses.Any())
{
break;
}
TypeParameterConstraintClauseSyntax first = constraintClauses.First();
SyntaxToken token = first.WhereKeyword.GetPreviousToken();
SyntaxTriviaList trivia = token.TrailingTrivia.EmptyIfWhitespace()
.AddRange(first.GetLeadingTrivia().EmptyIfWhitespace())
.AddRange(constraintClauses.Last().GetTrailingTrivia());
return(structDeclaration
.ReplaceToken(token, token.WithTrailingTrivia(trivia))
.WithConstraintClauses(default(SyntaxList <TypeParameterConstraintClauseSyntax>)));
}
case SyntaxKind.DelegateDeclaration:
{
var delegateDeclaration = (DelegateDeclarationSyntax)node;
SyntaxList <TypeParameterConstraintClauseSyntax> constraintClauses = delegateDeclaration.ConstraintClauses;
if (!constraintClauses.Any())
{
break;
}
TypeParameterConstraintClauseSyntax first = constraintClauses.First();
SyntaxToken token = first.WhereKeyword.GetPreviousToken();
SyntaxTriviaList trivia = token.TrailingTrivia.EmptyIfWhitespace()
.AddRange(first.GetLeadingTrivia().EmptyIfWhitespace())
.AddRange(constraintClauses.Last().GetTrailingTrivia());
return(delegateDeclaration
.ReplaceToken(token, token.WithTrailingTrivia(trivia))
.WithConstraintClauses(default(SyntaxList <TypeParameterConstraintClauseSyntax>)));
}
case SyntaxKind.MethodDeclaration:
{
var methodDeclaration = (MethodDeclarationSyntax)node;
SyntaxList <TypeParameterConstraintClauseSyntax> constraintClauses = methodDeclaration.ConstraintClauses;
if (!constraintClauses.Any())
{
break;
}
TypeParameterConstraintClauseSyntax first = constraintClauses.First();
SyntaxToken token = first.WhereKeyword.GetPreviousToken();
SyntaxTriviaList trivia = token.TrailingTrivia.EmptyIfWhitespace()
.AddRange(first.GetLeadingTrivia().EmptyIfWhitespace())
.AddRange(constraintClauses.Last().GetTrailingTrivia());
return(methodDeclaration
.ReplaceToken(token, token.WithTrailingTrivia(trivia))
.WithConstraintClauses(default(SyntaxList <TypeParameterConstraintClauseSyntax>)));
}
case SyntaxKind.LocalFunctionStatement:
{
var localFunctionStatement = (LocalFunctionStatementSyntax)node;
SyntaxList <TypeParameterConstraintClauseSyntax> constraintClauses = localFunctionStatement.ConstraintClauses;
if (!constraintClauses.Any())
{
break;
}
TypeParameterConstraintClauseSyntax first = constraintClauses.First();
SyntaxToken token = first.WhereKeyword.GetPreviousToken();
SyntaxTriviaList trivia = token.TrailingTrivia.EmptyIfWhitespace()
.AddRange(first.GetLeadingTrivia().EmptyIfWhitespace())
.AddRange(constraintClauses.Last().GetTrailingTrivia());
return(localFunctionStatement
.ReplaceToken(token, token.WithTrailingTrivia(trivia))
.WithConstraintClauses(default(SyntaxList <TypeParameterConstraintClauseSyntax>)));
}
}
return(node);
}
Document PerformAction(Document document, SemanticModel model, SyntaxNode root, PropertyBlockSyntax propertyDeclaration, bool needsSetter)
{
AccessorBlockSyntax accessor = null;
PropertyBlockSyntax newProp = null;
if (needsSetter)
{
accessor = SyntaxFactory.AccessorBlock(
SyntaxKind.SetAccessorBlock,
SyntaxFactory.AccessorStatement(SyntaxKind.SetAccessorStatement, SyntaxFactory.Token(SyntaxKind.SetKeyword))
.WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(new[] {
SyntaxFactory.Parameter(SyntaxFactory.List<AttributeListSyntax>(), SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ByValKeyword)), SyntaxFactory.ModifiedIdentifier("value"), SyntaxFactory.SimpleAsClause(propertyDeclaration.PropertyStatement.AsClause.Type().WithoutTrailingTrivia()), null)
}))),
SyntaxFactory.EndBlockStatement(SyntaxKind.EndSetStatement, SyntaxFactory.Token(SyntaxKind.SetKeyword)));
var getter = propertyDeclaration.Accessors.FirstOrDefault(m => m.IsKind(SyntaxKind.GetAccessorBlock));
if (getter != null)
{
var getField = getter.ScanGetter(model);
if (getField == null || getField.IsReadOnly)
{
// Readonly or no field can be found
accessor = accessor.WithStatements(SyntaxFactory.List<StatementSyntax>(new[] { GetNotImplementedThrowStatement() }));
}
else
{
// Now we add a 'field = value'.
accessor = accessor.WithStatements(SyntaxFactory.List<StatementSyntax>(new[] {
SyntaxFactory.AssignmentStatement(SyntaxKind.SimpleAssignmentStatement, SyntaxFactory.IdentifierName(getField.Name), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.IdentifierName("value")) }));
}
}
var modifierList = SyntaxFactory.TokenList(propertyDeclaration.PropertyStatement.Modifiers.Where(m => !m.IsKind(SyntaxKind.ReadOnlyKeyword)));
newProp = propertyDeclaration
.WithAccessors(propertyDeclaration.Accessors.Add(accessor))
.WithPropertyStatement(propertyDeclaration.PropertyStatement.WithModifiers(modifierList));
}
else
{
accessor = SyntaxFactory.AccessorBlock(SyntaxKind.GetAccessorBlock,
SyntaxFactory.AccessorStatement(SyntaxKind.GetAccessorStatement, SyntaxFactory.Token(SyntaxKind.GetKeyword)),
SyntaxFactory.EndBlockStatement(SyntaxKind.EndGetStatement, SyntaxFactory.Token(SyntaxKind.GetKeyword)));
var setter = propertyDeclaration.Accessors.FirstOrDefault(m => m.IsKind(SyntaxKind.SetAccessorBlock));
var accessorDeclList = new SyntaxList<AccessorBlockSyntax>();
if (setter != null)
{
var setField = setter.ScanSetter(model);
if (setField == null)
{
// No field can be found
accessor = accessor.WithStatements(SyntaxFactory.List<StatementSyntax>(new[] { GetNotImplementedThrowStatement() }));
}
else
{
// Add a 'Return field'.
accessor = accessor.WithStatements(SyntaxFactory.List<StatementSyntax>(
new[] { SyntaxFactory.ReturnStatement(SyntaxFactory.IdentifierName(setField.Name)) }));
}
accessorDeclList = accessorDeclList.Add(propertyDeclaration.Accessors.First(m => m.IsKind(SyntaxKind.SetAccessorBlock)));
}
accessorDeclList = accessorDeclList.Insert(0, accessor);
var accessorList = SyntaxFactory.List(accessorDeclList);
var modifierList = SyntaxFactory.TokenList(propertyDeclaration.PropertyStatement.Modifiers.Where(m => !m.IsKind(SyntaxKind.WriteOnlyKeyword)));
newProp = propertyDeclaration
.WithAccessors(accessorList)
.WithPropertyStatement(propertyDeclaration.PropertyStatement.WithModifiers(modifierList));
}
var newRoot = root.ReplaceNode(propertyDeclaration, newProp).WithAdditionalAnnotations(Formatter.Annotation);
return document.WithSyntaxRoot(newRoot);
}
public SyntaxList <TItem> Add(SyntaxList <TItem> list, TItem item)
{
return(list.Add(item));
}
private static SwitchSectionSyntax CreateSwitchSection(ISymbol symbol, TypeSyntax enumType, SyntaxList <StatementSyntax> statements)
{
return(SwitchSection(
SingletonList <SwitchLabelSyntax>(
CaseSwitchLabel(
SimpleMemberAccessExpression(
enumType,
IdentifierName(symbol.Name)))),
statements));
}
public static MethodBlockBaseSyntax WithStatements(this MethodBlockBaseSyntax syntax, SyntaxList<StatementSyntax> statements)
{
if (syntax == null)
throw new System.ArgumentNullException(nameof(syntax));
if (syntax is MethodBlockSyntax)
return ((MethodBlockSyntax)syntax).WithStatements(statements);
if (syntax is ConstructorBlockSyntax)
return ((ConstructorBlockSyntax)syntax).WithStatements(statements);
if (syntax is AccessorBlockSyntax)
return ((AccessorBlockSyntax)syntax).WithStatements(statements);
if (syntax is OperatorBlockSyntax)
return ((OperatorBlockSyntax)syntax).WithStatements(statements);
throw new System.NotSupportedException(syntax.GetType() + " is not supported!");
}
public SyntaxList <TItem> Replace(SyntaxList <TItem> list, TItem oldItem, TItem newItem)
{
return(list.Replace(oldItem, newItem));
}
public static void ComputeRefactoring(
RefactoringContext context,
SwitchStatementSyntax switchStatement,
SemanticModel semanticModel)
{
ExpressionSyntax expression = switchStatement.Expression;
if (expression?.IsMissing != false)
{
return;
}
SyntaxList <SwitchSectionSyntax> sections = switchStatement.Sections;
ISymbol symbol = semanticModel.GetSymbol(expression, context.CancellationToken);
if (symbol?.IsErrorType() != false)
{
return;
}
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(expression, context.CancellationToken);
if (typeSymbol?.TypeKind != TypeKind.Enum)
{
return;
}
if (!typeSymbol.ContainsMember <IFieldSymbol>())
{
return;
}
if (sections.Any() && !ContainsOnlyDefaultSection(sections))
{
if (context.Span.IsEmptyAndContainedInSpan(switchStatement.SwitchKeyword))
{
ImmutableArray <ISymbol> members = typeSymbol.GetMembers();
if (members.Length == 0)
{
return;
}
var fieldsToValue = new Dictionary <object, IFieldSymbol>(members.Length);
foreach (ISymbol member in members)
{
if (member.Kind == SymbolKind.Field)
{
var fieldSymbol = (IFieldSymbol)member;
if (fieldSymbol.HasConstantValue)
{
object constantValue = fieldSymbol.ConstantValue;
if (!fieldsToValue.ContainsKey(constantValue))
{
fieldsToValue.Add(constantValue, fieldSymbol);
}
}
}
}
foreach (SwitchSectionSyntax section in sections)
{
foreach (SwitchLabelSyntax label in section.Labels)
{
if (label is CaseSwitchLabelSyntax caseLabel)
{
ExpressionSyntax value = caseLabel.Value.WalkDownParentheses();
if (value?.IsMissing == false)
{
Optional <object> optional = semanticModel.GetConstantValue(value, context.CancellationToken);
if (optional.HasValue &&
fieldsToValue.Remove(optional.Value) &&
fieldsToValue.Count == 0)
{
return;
}
}
}
}
}
Document document = context.Document;
context.RegisterRefactoring(
Title,
ct => AddCasesAsync(document, switchStatement, fieldsToValue.Select(f => f.Value), ct),
RefactoringDescriptors.AddMissingCasesToSwitchStatement);
}
}
else if (context.IsRefactoringEnabled(RefactoringDescriptors.AddMissingCasesToSwitchStatement))
{
Document document = context.Document;
context.RegisterRefactoring(
Title,
ct => AddCasesAsync(document, switchStatement, semanticModel, ct),
RefactoringDescriptors.AddMissingCasesToSwitchStatement);
}
}
public SyntaxList <TItem> RemoveAt(SyntaxList <TItem> list, int index)
{
return(list.RemoveAt(index));
}
public SyntaxList <TItem> Remove(SyntaxList <TItem> list, TItem item)
{
return(list.Remove(item));
}
public SyntaxList <TItem> Insert(SyntaxList <TItem> list, int index, TItem item)
{
return(list.Insert(index, item));
}
private static void ReplaceMethodTextCSharp(SyntaxNode node, IDocument document, string textToSearch)
{
string methodText = node.GetText().ToString();
bool isMethod = node is MethodDeclarationSyntax;
string methodOrPropertyDefinition = isMethod ? "Method: " : " Invalid - not Method ";
object methodName = ((MethodDeclarationSyntax)node).Identifier.Value;
var body = (node as MethodDeclarationSyntax).Body;
var statements = body.Statements;
var originalTrailingTrivia = body.GetTrailingTrivia();
SyntaxList<StatementSyntax> newStatements = new SyntaxList<StatementSyntax>();
StatementSyntax statementNewTestmap = Syntax.ParseStatement("var testmap = new Dictionary<string, object>();");
newStatements = newStatements.Add(statementNewTestmap);
SyntaxList<StatementSyntax> flattenedStmts = Flatten(statements);
foreach (var statement in flattenedStmts)
{
//string stmtString = RemoveComments(statement).ToString();
string stmtString = statement.ToString();
stmtString = RemoveComments(stmtString);
if (Regex.IsMatch(stmtString, "\\b" + textToSearch + "\\b"))
{
StatementSyntax newStatement = null;
//string[] parameters = stmtString.Split(new char[] { '(', ',', ')' });
//if(parameters.Length == 4)
//{
// if(parameters.Last() == "1")
// {
// Console.WriteLine(stmtString);
// }
//}
//stmtString = TestmapAdd + "(" + parameters.ElementAt(1) + ", " + parameters.ElementAt(2) + ");" ;
var invocation = Syntax.ParseExpression(RemoveComments(stmtString)) as InvocationExpressionSyntax;
var args = invocation.ArgumentList.Arguments;
//var args = GetParams(stmtString);
if (args.Count() > 3)
{
throw new Exception();
}
if (args.Count() == 3)
{
#if DEBUG
if (args.Last().ToString() != "0")
Console.WriteLine(stmtString);
#endif
// Console.WriteLine(stmtString);
//stmtString = TestmapAdd + "(" + args.ElementAt(0) + ", " + args.ElementAt(1) + ");";
try
{
var registerArgs = new List<ArgumentSyntax>
{
args.ElementAt(0),
args.ElementAt(1)
};
var argSeparators = Enumerable.Repeat(Syntax.Token(SyntaxKind.CommaToken), registerArgs.Count - 1).ToList();
ArgumentListSyntax newArgList = Syntax.ArgumentList(
arguments: Syntax.SeparatedList(
registerArgs,
argSeparators));
InvocationExpressionSyntax newInvokationNode = Syntax.InvocationExpression(
Syntax.MemberAccessExpression(
kind: SyntaxKind.MemberAccessExpression,
expression: Syntax.ParseName("testmap"),
name: Syntax.IdentifierName("Add"),
operatorToken: Syntax.Token(SyntaxKind.DotToken)),
newArgList);
stmtString = newInvokationNode.ToString() + ";";
newStatement = Syntax.ParseStatement(stmtString);
}
catch(Exception e)
{
Console.WriteLine(e);
}
}
if(args.Count() == 2)
{
stmtString = stmtString.Replace(textToSearch, TestmapAdd);
}
Console.WriteLine(stmtString);
newStatement = Syntax.ParseStatement(stmtString);
try
{
newStatements = newStatements.Add(newStatement);
}
catch (Exception e)
{
Console.WriteLine(e);
}
//stmtString.Replace(textToSearch, "thisTest.GenericVerify");
}
else
newStatements = newStatements.Add(statement);
}
newStatements = newStatements.Add(Syntax.ParseStatement("thisTest.GenericVerify(testmap);"));
FileRoot = FileRoot.ReplaceNode(body,
Syntax.Block(newStatements).WithTrailingTrivia(originalTrailingTrivia)).NormalizeWhitespace();
}
internal override IEnumerable <KeyValuePair <string, string> > StringifyAttributes(SyntaxList <RazorSyntaxNode> attributes)
{
var stringifiedAttributes = new List <KeyValuePair <string, string> >();
for (var i = 0; i < attributes.Count; i++)
{
var attribute = attributes[i];
if (attribute is MarkupTagHelperAttributeSyntax tagHelperAttribute)
{
var name = tagHelperAttribute.Name.GetContent();
var value = tagHelperAttribute.Value?.GetContent() ?? string.Empty;
stringifiedAttributes.Add(new KeyValuePair <string, string>(name, value));
}
else if (attribute is MarkupMinimizedTagHelperAttributeSyntax minimizedTagHelperAttribute)
{
var name = minimizedTagHelperAttribute.Name.GetContent();
stringifiedAttributes.Add(new KeyValuePair <string, string>(name, string.Empty));
}
else if (attribute is MarkupAttributeBlockSyntax markupAttribute)
{
var name = markupAttribute.Name.GetContent();
var value = markupAttribute.Value?.GetContent() ?? string.Empty;
stringifiedAttributes.Add(new KeyValuePair <string, string>(name, value));
}
else if (attribute is MarkupMinimizedAttributeBlockSyntax minimizedMarkupAttribute)
{
var name = minimizedMarkupAttribute.Name.GetContent();
stringifiedAttributes.Add(new KeyValuePair <string, string>(name, string.Empty));
}
else if (attribute is MarkupTagHelperDirectiveAttributeSyntax directiveAttribute)
{
var name = directiveAttribute.FullName;
var value = directiveAttribute.Value?.GetContent() ?? string.Empty;
stringifiedAttributes.Add(new KeyValuePair <string, string>(name, value));
}
else if (attribute is MarkupMinimizedTagHelperDirectiveAttributeSyntax minimizedDirectiveAttribute)
{
var name = minimizedDirectiveAttribute.FullName;
stringifiedAttributes.Add(new KeyValuePair <string, string>(name, string.Empty));
}
}
return(stringifiedAttributes);
}
private static SyntaxList<StatementSyntax> Flatten(StatementSyntax stmt, SyntaxList<StatementSyntax> result)
{
if (!(stmt is BlockSyntax))
result = result.Add(stmt);
else
{
foreach(var item in (stmt as BlockSyntax).Statements)
{
result = Flatten(item, result);
}
}
return result;
}
private static Task <Document> IfToReturnWithCoalesceExpressionAsync(
Document document,
IfToReturnWithCoalesceExpressionAnalysis analysis,
CancellationToken cancellationToken = default(CancellationToken))
{
IfStatementSyntax ifStatement = analysis.IfStatement;
int position = ifStatement.SpanStart;
ITypeSymbol targetType = GetTargetType();
BinaryExpressionSyntax coalesceExpression = CreateCoalesceExpression(
analysis.Left.WithoutTrivia(),
analysis.Right.WithoutTrivia(),
targetType,
position,
analysis.SemanticModel);
StatementSyntax statement;
if (analysis.IsYield)
{
statement = YieldReturnStatement(coalesceExpression);
}
else
{
statement = ReturnStatement(coalesceExpression);
}
if (ifStatement.IsSimpleIf())
{
StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(ifStatement);
SyntaxList <StatementSyntax> statements = statementsInfo.Statements;
int index = statements.IndexOf(ifStatement);
StatementSyntax newNode = statement
.WithLeadingTrivia(ifStatement.GetLeadingTrivia())
.WithTrailingTrivia(statements[index + 1].GetTrailingTrivia())
.WithFormatterAnnotation();
SyntaxList <StatementSyntax> newStatements = statements
.RemoveAt(index)
.ReplaceAt(index, newNode);
return(document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken));
}
else
{
StatementSyntax newNode = statement
.WithTriviaFrom(ifStatement)
.WithFormatterAnnotation();
return(document.ReplaceNodeAsync(ifStatement, newNode, cancellationToken));
}
ITypeSymbol GetTargetType()
{
IMethodSymbol methodSymbol = analysis.SemanticModel.GetEnclosingSymbol <IMethodSymbol>(position, cancellationToken);
Debug.Assert(methodSymbol != null, "");
if (methodSymbol?.IsErrorType() == false)
{
ITypeSymbol returnType = methodSymbol.ReturnType;
if (!returnType.IsErrorType())
{
if (methodSymbol.IsAsync)
{
if (returnType.OriginalDefinition.EqualsOrInheritsFrom(MetadataNames.System_Threading_Tasks_Task_T))
{
return(((INamedTypeSymbol)returnType).TypeArguments[0]);
}
}
else if (!analysis.IsYield)
{
return(returnType);
}
else if (returnType.SpecialType == SpecialType.System_Collections_IEnumerable)
{
return(analysis.SemanticModel.Compilation.ObjectType);
}
else if (returnType.OriginalDefinition.IsIEnumerableOfT())
{
return(((INamedTypeSymbol)returnType).TypeArguments[0]);
}
}
}
return(null);
}
}
private PropertyDeclarationSyntax CreateChildPropertyDeclaration(string propertyIdentifierName, string targetFieldName, SyntaxList<MemberDeclarationSyntax> syntaxList, Type returnType)
{
//OpenPorts
//nmaprunHostsPorts
string name = "";
foreach (PropertyDeclarationSyntax prop in syntaxList.Where(m => m is PropertyDeclarationSyntax))
{
if (prop.Type.ToString().Contains(targetFieldName))
{
name = prop.Identifier.ToString();
break;
}
}
MemberAccessExpressionSyntax memAcc = Syntax.MemberAccessExpression(SyntaxKind.MemberAccessExpression, Syntax.ThisExpression(), Syntax.IdentifierName(name));
ReturnStatementSyntax rs = Syntax.ReturnStatement(memAcc);
SyntaxList<ReturnStatementSyntax> list = Syntax.List(rs);
BlockSyntax block = Syntax.Block(list);
AccessorDeclarationSyntax acc = Syntax.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, block);
PropertyDeclarationSyntax pd = Syntax.PropertyDeclaration(null,
Syntax.TokenList(new SyntaxToken[] { Syntax.Token(SyntaxKind.PublicKeyword), Syntax.Token(SyntaxKind.OverrideKeyword) }),
Syntax.ParseTypeName(returnType.FullName + "[]"),
null,
Syntax.Identifier(propertyIdentifierName),
Syntax.AccessorList(Syntax.List(acc)));
return pd;
}
private static bool IsFixableSimpleIfInsideWhileOrDo(
IfStatementSyntax ifStatement,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
SyntaxNode parent = ifStatement.Parent;
if (parent.Kind() != SyntaxKind.Block)
{
return(false);
}
if (ifStatement.SingleNonBlockStatementOrDefault()?.Kind() != SyntaxKind.BreakStatement)
{
return(false);
}
var block = (BlockSyntax)parent;
SyntaxList <StatementSyntax> statements = block.Statements;
int count = statements.Count;
if (count == 1)
{
return(false);
}
int index = statements.IndexOf(ifStatement);
if (index != 0 &&
index != count - 1)
{
return(false);
}
parent = block.Parent;
SyntaxKind kind = parent.Kind();
if (kind == SyntaxKind.WhileStatement)
{
var whileStatement = (WhileStatementSyntax)parent;
if (whileStatement.SpanContainsDirectives())
{
return(false);
}
if (whileStatement.Condition?.WalkDownParentheses().Kind() != SyntaxKind.TrueLiteralExpression)
{
return(false);
}
if (index == count - 1 &&
ContainsLocalDefinedInLoopBody(
ifStatement.Condition,
TextSpan.FromBounds(block.SpanStart, ifStatement.SpanStart),
semanticModel,
cancellationToken))
{
return(false);
}
return(true);
}
else if (kind == SyntaxKind.DoStatement)
{
var doStatement = (DoStatementSyntax)parent;
if (doStatement.SpanContainsDirectives())
{
return(false);
}
if (doStatement.Condition?.WalkDownParentheses().Kind() != SyntaxKind.TrueLiteralExpression)
{
return(false);
}
if (index == count - 1 &&
ContainsLocalDefinedInLoopBody(
ifStatement.Condition,
TextSpan.FromBounds(block.SpanStart, ifStatement.SpanStart),
semanticModel,
cancellationToken))
{
return(false);
}
return(true);
}
return(false);
}
internal TypeDeclarationSyntax(SyntaxKind syntaxKind)
: base(syntaxKind)
{
ConstraintClauses = new SyntaxList<TypeParameterConstraintClauseSyntax>(this);
Members = new SyntaxList<MemberDeclarationSyntax>(this);
}
private static SyntaxNode Refactor(MemberDeclarationSyntax member)
{
switch (member.Parent.Kind())
{
case SyntaxKind.CompilationUnit:
{
var parent = (CompilationUnitSyntax)member.Parent;
SyntaxList <MemberDeclarationSyntax> members = parent.Members;
int index = members.IndexOf(member);
return(parent.WithMembers(members.Insert(index + 1, member.WithNavigationAnnotation())));
}
case SyntaxKind.NamespaceDeclaration:
{
var parent = (NamespaceDeclarationSyntax)member.Parent;
SyntaxList <MemberDeclarationSyntax> members = parent.Members;
int index = members.IndexOf(member);
if (index == 0 &&
parent.OpenBraceToken.GetFullSpanEndLine() == member.GetFullSpanStartLine())
{
member = member.WithLeadingTrivia(member.GetLeadingTrivia().Insert(0, NewLine()));
}
return(parent.WithMembers(members.Insert(index + 1, member.WithNavigationAnnotation())));
}
case SyntaxKind.ClassDeclaration:
{
var parent = (ClassDeclarationSyntax)member.Parent;
SyntaxList <MemberDeclarationSyntax> members = parent.Members;
int index = members.IndexOf(member);
if (index == 0 &&
parent.OpenBraceToken.GetFullSpanEndLine() == member.GetFullSpanStartLine())
{
member = member.WithLeadingTrivia(member.GetLeadingTrivia().Insert(0, NewLine()));
}
return(parent.WithMembers(members.Insert(index + 1, member.WithNavigationAnnotation())));
}
case SyntaxKind.StructDeclaration:
{
var parent = (StructDeclarationSyntax)member.Parent;
SyntaxList <MemberDeclarationSyntax> members = parent.Members;
int index = members.IndexOf(member);
if (index == 0 &&
parent.OpenBraceToken.GetFullSpanEndLine() == member.GetFullSpanStartLine())
{
member = member.WithLeadingTrivia(member.GetLeadingTrivia().Insert(0, NewLine()));
}
return(parent.WithMembers(members.Insert(index + 1, member.WithNavigationAnnotation())));
}
case SyntaxKind.InterfaceDeclaration:
{
var parent = (InterfaceDeclarationSyntax)member.Parent;
SyntaxList <MemberDeclarationSyntax> members = parent.Members;
int index = members.IndexOf(member);
if (index == 0 &&
parent.OpenBraceToken.GetFullSpanEndLine() == member.GetFullSpanStartLine())
{
member = member.WithLeadingTrivia(member.GetLeadingTrivia().Insert(0, NewLine()));
}
return(parent.WithMembers(members.Insert(index + 1, member.WithNavigationAnnotation())));
}
}
return(null);
}
public static IEnumerable <AttributeSyntax> GetAttributes(this SyntaxList <AttributeListSyntax> attributeLists,
ImmutableArray <KnownType> attributeKnownTypes, SemanticModel semanticModel) =>
attributeLists.SelectMany(list => list.Attributes)
.Where(a => semanticModel.GetTypeInfo(a).Type.IsAny(attributeKnownTypes));
public static void AnalyzeWhileStatement(SyntaxNodeAnalysisContext context)
{
var whileStatement = (WhileStatementSyntax)context.Node;
ExpressionSyntax condition = whileStatement.Condition;
if (condition.IsMissing)
{
return;
}
if (!condition.IsSingleLine())
{
return;
}
StatementSyntax statement = whileStatement.Statement;
if (!statement.IsKind(SyntaxKind.Block))
{
return;
}
var block = (BlockSyntax)statement;
SyntaxList <StatementSyntax> innerStatements = block.Statements;
if (innerStatements.Count <= 1)
{
return;
}
ExpressionSyntax incrementedExpression = GetIncrementedExpression(innerStatements.Last());
if (!incrementedExpression.IsKind(SyntaxKind.IdentifierName))
{
return;
}
SyntaxList <StatementSyntax> outerStatements = SyntaxInfo.StatementListInfo(whileStatement).Statements;
int index = outerStatements.IndexOf(whileStatement);
if (index <= 0)
{
return;
}
SingleLocalDeclarationStatementInfo localInfo = GetLocalInfo(outerStatements[index - 1]);
if (!localInfo.Success)
{
return;
}
if (index > 1)
{
SingleLocalDeclarationStatementInfo localInfo2 = GetLocalInfo(outerStatements[index - 2]);
if (localInfo2.Success)
{
ExpressionSyntax incrementedExpression2 = GetIncrementedExpression(innerStatements[innerStatements.Count - 2]);
if (incrementedExpression2.IsKind(SyntaxKind.IdentifierName))
{
var identifierName2 = (IdentifierNameSyntax)incrementedExpression2;
if (string.Equals(localInfo2.Identifier.ValueText, identifierName2.Identifier.ValueText, StringComparison.Ordinal))
{
return;
}
}
}
}
var identifierName = (IdentifierNameSyntax)incrementedExpression;
if (!string.Equals(localInfo.Identifier.ValueText, identifierName.Identifier.ValueText, StringComparison.Ordinal))
{
return;
}
if (ContainsContinueStatement())
{
return;
}
SemanticModel semanticModel = context.SemanticModel;
CancellationToken cancellationToken = context.CancellationToken;
ISymbol symbol = semanticModel.GetDeclaredSymbol(localInfo.Declarator, cancellationToken);
if (symbol?.Kind != SymbolKind.Local)
{
return;
}
if (IsLocalVariableReferencedAfterWhileStatement())
{
return;
}
DiagnosticHelpers.ReportDiagnostic(context, DiagnosticDescriptors.UseForStatementInsteadOfWhileStatement, whileStatement.WhileKeyword);
bool ContainsContinueStatement()
{
ContainsContinueStatementWalker walker = ContainsContinueStatementWalker.GetInstance();
bool containsContinueStatement = false;
foreach (StatementSyntax innerStatement in innerStatements)
{
walker.Visit(innerStatement);
if (walker.ContainsContinueStatement)
{
containsContinueStatement = true;
break;
}
}
ContainsContinueStatementWalker.Free(walker);
return(containsContinueStatement);
}
bool IsLocalVariableReferencedAfterWhileStatement()
{
ContainsLocalOrParameterReferenceWalker walker = ContainsLocalOrParameterReferenceWalker.GetInstance(symbol, semanticModel, cancellationToken);
walker.VisitList(outerStatements, index + 1);
return(ContainsLocalOrParameterReferenceWalker.GetResultAndFree(walker));
}
}
internal BaseArgumentListSyntax(SyntaxKind syntaxKind)
: base(syntaxKind)
{
Arguments = new SyntaxList<ArgumentSyntax>(this);
}
public static LocalFunctionStatementSyntax LocalFunctionStatement(SyntaxTokenList modifiers, TypeSyntax returnType, SyntaxToken identifier, TypeParameterListSyntax typeParameterList, ParameterListSyntax parameterList, SyntaxList <TypeParameterConstraintClauseSyntax> constraintClauses, BlockSyntax body, ArrowExpressionClauseSyntax expressionBody)
{
return(LocalFunctionStatement(attributeLists: default, modifiers, returnType, identifier, typeParameterList, parameterList, constraintClauses, body, expressionBody, semicolonToken: default));
public static SyntaxNode WithMembers(this SyntaxNode node, SyntaxList<MemberDeclarationSyntax> members)
{
MethodInfo method = node.GetType().GetMethod("WithMembers");
return (SyntaxNode)method.Invoke(node, new object[] { members });
}
private static void ReportIssue(SyntaxList <StatementSyntax> statementsToReport, SyntaxList <StatementSyntax> locationProvider,
SyntaxNodeAnalysisContext context, string constructType)
{
var firstStatement = statementsToReport.FirstOrDefault();
if (firstStatement == null)
{
return;
}
var lastStatement = statementsToReport.Last();
var location = Location.Create(context.Node.SyntaxTree,
TextSpan.FromBounds(firstStatement.SpanStart, lastStatement.Span.End));
context.ReportDiagnostic(Diagnostic.Create(rule,
location, locationProvider.First().GetLineNumberToReport(), constructType));
}
private PropertyDeclarationSyntax CreateStringProperty(string propertyIdentifierName, string targetFieldName, string startType, SyntaxList<MemberDeclarationSyntax> syntaxList, DynamicPlugin dp)
{
List<string> path = dp.FindStringPath(targetFieldName, startType);
string name = "";
if (path.Count == 1)
{
name = path.First();
}
else if (path.Count > 1)
{
foreach (string obj in path.Skip(1).Take(path.Count - 1))
{
string val = "";
foreach (ClassDeclarationSyntax classes in syntaxList.Where(m => m is ClassDeclarationSyntax))
{
foreach (PropertyDeclarationSyntax prop in classes.Members.Where(m => m is PropertyDeclarationSyntax))
{
if (prop.Type.ToString().Contains(obj + "[]"))
{
val = prop.Identifier.ToString();
break;
}
}
if (val != "")
break;
}
if (val != "")
name += val + "[0].";
}
name += path.Last();
}
ExpressionSyntax expr;
if (name != "")
expr = Syntax.MemberAccessExpression(SyntaxKind.MemberAccessExpression, Syntax.ThisExpression(), Syntax.IdentifierName(name));
else
expr = Syntax.BaseExpression(Syntax.Token(SyntaxKind.NullKeyword));
ReturnStatementSyntax rs = Syntax.ReturnStatement(expr);
SyntaxList<ReturnStatementSyntax> list = Syntax.List(rs);
BlockSyntax block = Syntax.Block(list);
AccessorDeclarationSyntax acc = Syntax.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, block);
PropertyDeclarationSyntax pd2 = Syntax.PropertyDeclaration(null,
Syntax.TokenList(new SyntaxToken[] { Syntax.Token(SyntaxKind.PublicKeyword), Syntax.Token(SyntaxKind.OverrideKeyword) }),
Syntax.ParseTypeName("string"),
null,
Syntax.Identifier(propertyIdentifierName),
Syntax.AccessorList(Syntax.List(acc)));
return pd2;
}
private static void ProcessUsings(List <Dictionary <string, string> > aliasMaps, SyntaxList <UsingDirectiveSyntax> usings)
{
Dictionary <string, string> aliasMap = null;
foreach (var usingDecl in usings)
{
if (usingDecl.Alias != null)
{
var mappedName = GetTypeName(usingDecl.Name);
if (mappedName != null)
{
aliasMap ??= AllocateAliasMap();
// If we have: using X = Goo, then we store a mapping from X -> Goo
// here. That way if we see a class that inherits from X we also state
// that it inherits from Goo as well.
aliasMap[usingDecl.Alias.Name.Identifier.ValueText] = mappedName;
}
}
}
if (aliasMap != null)
{
aliasMaps.Add(aliasMap);
}
}
static bool IsLastStatement(SyntaxList<StatementSyntax> statements, MultiLineIfBlockSyntax ifBlock)
{
return statements.IndexOf(ifBlock) + 1 >= statements.Count;
}
private static void Analyze(
SyntaxNodeAnalysisContext context,
SyntaxList <StatementSyntax> statements,
in SingleLocalDeclarationStatementInfo localDeclarationInfo,
private static SyntaxList<StatementSyntax> Flatten(SyntaxList<StatementSyntax> statements)
{
SyntaxList<StatementSyntax> result = new SyntaxList<StatementSyntax>();
foreach(var stmt in statements)
{
if (!(stmt is BlockSyntax))
result = result.Add(stmt);
else
result = Flatten(stmt, result);
}
return result;
}
private SyntaxList <StatementSyntax> CreateNewStatements(List <string> statinfos, SyntaxList <StatementSyntax> statements)
{
var outStatements = new SyntaxList <StatementSyntax>()
{
};
foreach (var statinfo in statinfos)
{
if (IsOriginalStatement(statinfo))
{
int origId = int.Parse(statinfo);
var newStment = statements[origId];
outStatements = outStatements.Add(newStment);
}
else
{
var newStmt = SyntaxFactory.ParseStatement(statinfo);
outStatements = outStatements.Add(newStmt);
}
}
return(outStatements);
}
internal BaseParameterListSyntax(SyntaxKind syntaxKind)
: base(syntaxKind)
{
Parameters = new SyntaxList<ParameterSyntax>(this);
}
internal Enumerator(SyntaxList <TNode> list)
{
_list = list;
_index = -1;
}
public static bool AreEquivalent(SyntaxList<SyntaxNode> nodeList1, SyntaxList<SyntaxNode> nodeList2)
{
return Common.EquivalenceChecker.AreEquivalent(nodeList1, nodeList2,
(n1, n2) => SyntaxFactory.AreEquivalent(n1, n2));
}
private static void AnalyzeLocalDeclarationStatement(SyntaxNodeAnalysisContext context)
{
if (context.Node.ContainsDiagnostics)
{
return;
}
var localDeclaration = (LocalDeclarationStatementSyntax)context.Node;
if (localDeclaration.IsConst)
{
return;
}
StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(localDeclaration);
if (!statementsInfo.Success)
{
return;
}
SyntaxList <StatementSyntax> statements = statementsInfo.Statements;
if (statements.Count <= 1)
{
return;
}
int index = statements.IndexOf(localDeclaration);
if (index == statements.Count - 1)
{
return;
}
LocalDeclarationStatementInfo localInfo = SyntaxInfo.LocalDeclarationStatementInfo(localDeclaration);
if (!localInfo.Success)
{
return;
}
ITypeSymbol typeSymbol = context.SemanticModel.GetTypeSymbol(localInfo.Type, context.CancellationToken);
if (typeSymbol?.SupportsConstantValue() != true)
{
return;
}
if (localInfo.Type.IsVar && !typeSymbol.SupportsExplicitDeclaration())
{
return;
}
foreach (VariableDeclaratorSyntax declarator in localInfo.Variables)
{
if (!HasConstantValue(declarator.Initializer?.Value, typeSymbol, context.SemanticModel, context.CancellationToken))
{
return;
}
}
if (!CanBeMarkedAsConst(localInfo.Variables, statements, index + 1))
{
return;
}
DiagnosticHelpers.ReportDiagnostic(context, DiagnosticRules.MarkLocalVariableAsConst, localInfo.Type);
}
internal BasePropertyDeclarationSyntax(SyntaxKind syntaxKind)
: base(syntaxKind)
{
AttributeLists = new SyntaxList<AttributeListSyntax>(this);
}
public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
{
var document = context.Document;
if (document.Project.Solution.Workspace.Kind == WorkspaceKind.MiscellaneousFiles)
{
return;
}
var span = context.Span;
if (!span.IsEmpty)
{
return;
}
var cancellationToken = context.CancellationToken;
if (cancellationToken.IsCancellationRequested)
{
return;
}
var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
if (model.IsFromGeneratedCode(cancellationToken))
{
return;
}
var root = await model.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
var property = root.FindNode(span) as PropertyDeclarationSyntax;
if (property == null || !property.Identifier.Span.Contains(span))
{
return;
}
if (property.AccessorList?.Accessors.Any(b => !IsEmptyOrNotImplemented(b.Body)) != false) //ignore properties with >=1 accessor body
{
return;
}
TypeDeclarationSyntax enclosingTypeDeclaration = property.Ancestors().OfType <TypeDeclarationSyntax>().FirstOrDefault();
if (enclosingTypeDeclaration == null || enclosingTypeDeclaration is InterfaceDeclarationSyntax)
{
return;
}
context.RegisterRefactoring(
CodeActionFactory.Create(
property.Identifier.Span,
DiagnosticSeverity.Info,
GettextCatalog.GetString("To property with backing field"),
t2 =>
{
string name = GetNameProposal(property.Identifier.ValueText, model, root);
//create our backing store
var backingStore = SyntaxFactory.FieldDeclaration(
SyntaxFactory.VariableDeclaration(
property.Type,
SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>(SyntaxFactory.VariableDeclarator(name)))
).WithModifiers(!property.Modifiers.Any(m => m.IsKind(SyntaxKind.StaticKeyword)) ?
SyntaxFactory.TokenList() :
SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.StaticKeyword)))
.WithAdditionalAnnotations(Formatter.Annotation);
//create our new property
var fieldExpression = name == "value" ?
(ExpressionSyntax)SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName("value")) :
SyntaxFactory.IdentifierName(name);
var newPropAnno = new SyntaxAnnotation();
var syntaxList = new SyntaxList <AccessorDeclarationSyntax>();
var hasSetter = property.AccessorList.Accessors.Any(acc => acc.IsKind(SyntaxKind.SetAccessorDeclaration));
var hasGetter = property.AccessorList.Accessors.Any(acc => acc.IsKind(SyntaxKind.GetAccessorDeclaration));
if (hasGetter)
{
var getBody = SyntaxFactory.Block(SyntaxFactory.ReturnStatement(fieldExpression));
var getter = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, getBody);
getter = getter.WithModifiers(property.AccessorList.Accessors.First(acc => acc.IsKind(SyntaxKind.GetAccessorDeclaration)).Modifiers);
syntaxList = syntaxList.Add(getter);
if (!hasSetter)
{
backingStore = backingStore.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)));
}
}
if (hasSetter)
{
var setBody = SyntaxFactory.Block(SyntaxFactory.ExpressionStatement(
SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, fieldExpression,
SyntaxFactory.IdentifierName("value"))));
var setter = SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration, setBody);
setter = setter.WithModifiers(property.AccessorList.Accessors.First(acc => acc.IsKind(SyntaxKind.SetAccessorDeclaration)).Modifiers);
syntaxList = syntaxList.Add(setter);
}
var newProperty = property.WithAccessorList(SyntaxFactory.AccessorList(syntaxList))
.WithAdditionalAnnotations(newPropAnno, Formatter.Annotation);
var newRoot = root.ReplaceNode((SyntaxNode)property, newProperty);
return(Task.FromResult(document.WithSyntaxRoot(newRoot.InsertNodesBefore(newRoot.GetAnnotatedNodes(newPropAnno).First(), new List <SyntaxNode>()
{
backingStore
}))));
})
);
}
private static void AnalyzeInterpolatedStringExpression(SyntaxNodeAnalysisContext context)
{
SyntaxNode node = context.Node;
if (node.ContainsDiagnostics)
{
return;
}
if (node.ContainsDirectives)
{
return;
}
var interpolatedString = (InterpolatedStringExpressionSyntax)node;
SyntaxList <InterpolatedStringContentSyntax> contents = interpolatedString.Contents;
if (ConvertInterpolatedStringToStringLiteralAnalysis.IsFixable(contents))
{
ReportDiagnostic(context,
DiagnosticDescriptors.UnnecessaryInterpolatedString,
Location.Create(interpolatedString.SyntaxTree, GetDollarSpan(interpolatedString)));
}
else
{
if (!(contents.SingleOrDefault(shouldThrow: false) is InterpolationSyntax interpolation))
{
return;
}
if (interpolation.AlignmentClause != null)
{
return;
}
if (interpolation.FormatClause != null)
{
return;
}
ExpressionSyntax expression = interpolation.Expression?.WalkDownParentheses();
if (expression == null)
{
return;
}
if (!IsNonNullStringExpression(expression))
{
return;
}
ReportDiagnostic(context, DiagnosticDescriptors.UnnecessaryInterpolatedString, interpolatedString);
ReportToken(context, DiagnosticDescriptors.UnnecessaryInterpolatedStringFadeOut, interpolatedString.StringStartToken);
ReportToken(context, DiagnosticDescriptors.UnnecessaryInterpolatedStringFadeOut, interpolation.OpenBraceToken);
ReportToken(context, DiagnosticDescriptors.UnnecessaryInterpolatedStringFadeOut, interpolation.CloseBraceToken);
ReportToken(context, DiagnosticDescriptors.UnnecessaryInterpolatedStringFadeOut, interpolatedString.StringEndToken);
}
bool IsNonNullStringExpression(ExpressionSyntax expression)
{
if (expression.IsKind(SyntaxKind.StringLiteralExpression, SyntaxKind.InterpolatedStringExpression))
{
return(true);
}
Optional <object> constantValue = context.SemanticModel.GetConstantValue(expression, context.CancellationToken);
return(constantValue.HasValue &&
constantValue.Value is string value &&
value != null);
}
}
public abstract bool TryGetElementInfo(SyntaxNode element, out SyntaxToken containingTagNameToken, out SyntaxList <RazorSyntaxNode> attributeNodes);
public static bool Contains <T>(this SyntaxList <T> list, SyntaxKind kind) where T : SyntaxNode
{
return(list.IndexOf(kind) != -1);
}
private static void AnalyzeLocalDeclarationStatement(SyntaxNodeAnalysisContext context)
{
var localDeclarationStatement = (LocalDeclarationStatementSyntax)context.Node;
if (localDeclarationStatement.ContainsDiagnostics)
{
return;
}
if (localDeclarationStatement.SpanOrTrailingTriviaContainsDirectives())
{
return;
}
SingleLocalDeclarationStatementInfo localDeclarationInfo = SyntaxInfo.SingleLocalDeclarationStatementInfo(localDeclarationStatement);
if (!localDeclarationInfo.Success)
{
return;
}
ExpressionSyntax value = localDeclarationInfo.Value;
if (value == null)
{
return;
}
SyntaxList <StatementSyntax> statements = SyntaxInfo.StatementListInfo(localDeclarationStatement).Statements;
if (!statements.Any())
{
return;
}
int index = statements.IndexOf(localDeclarationStatement);
if (index == statements.Count - 1)
{
return;
}
StatementSyntax nextStatement = statements[index + 1];
if (nextStatement.ContainsDiagnostics)
{
return;
}
switch (nextStatement.Kind())
{
case SyntaxKind.ExpressionStatement:
{
Analyze(context, statements, localDeclarationInfo, index, (ExpressionStatementSyntax)nextStatement);
break;
}
case SyntaxKind.LocalDeclarationStatement:
{
Analyze(context, statements, localDeclarationInfo, index, (LocalDeclarationStatementSyntax)nextStatement);
break;
}
case SyntaxKind.ReturnStatement:
{
var returnStatement = (ReturnStatementSyntax)nextStatement;
if (!returnStatement.SpanOrLeadingTriviaContainsDirectives())
{
ExpressionSyntax expression = returnStatement.Expression;
if (expression?.Kind() == SyntaxKind.IdentifierName)
{
var identifierName = (IdentifierNameSyntax)expression;
if (string.Equals(localDeclarationInfo.IdentifierText, identifierName.Identifier.ValueText, StringComparison.Ordinal))
{
ReportDiagnostic(context, localDeclarationInfo, expression);
}
}
}
break;
}
case SyntaxKind.YieldReturnStatement:
{
var yieldStatement = (YieldStatementSyntax)nextStatement;
if (index == statements.Count - 2 &&
!yieldStatement.SpanOrLeadingTriviaContainsDirectives())
{
ExpressionSyntax expression = yieldStatement.Expression;
if (expression?.Kind() == SyntaxKind.IdentifierName)
{
var identifierName = (IdentifierNameSyntax)expression;
if (string.Equals(localDeclarationInfo.IdentifierText, identifierName.Identifier.ValueText, StringComparison.Ordinal))
{
ReportDiagnostic(context, localDeclarationInfo, expression);
}
}
}
break;
}
case SyntaxKind.ForEachStatement:
{
if (value.WalkDownParentheses().IsKind(SyntaxKind.AwaitExpression))
{
return;
}
if (!value.IsSingleLine())
{
return;
}
if (value.IsKind(SyntaxKind.ArrayInitializerExpression))
{
return;
}
var forEachStatement = (ForEachStatementSyntax)nextStatement;
ISymbol localSymbol = GetLocalSymbol(localDeclarationInfo, forEachStatement.Expression, context.SemanticModel, context.CancellationToken);
if (localSymbol?.IsErrorType() != false)
{
return;
}
ContainsLocalOrParameterReferenceWalker walker = ContainsLocalOrParameterReferenceWalker.GetInstance(localSymbol, context.SemanticModel, context.CancellationToken);
walker.Visit(forEachStatement.Statement);
if (!walker.Result &&
index < statements.Count - 2)
{
walker.VisitList(statements, index + 2);
}
if (ContainsLocalOrParameterReferenceWalker.GetResultAndFree(walker))
{
return;
}
ReportDiagnostic(context, localDeclarationInfo, forEachStatement.Expression);
break;
}
case SyntaxKind.SwitchStatement:
{
if (value.WalkDownParentheses().IsKind(SyntaxKind.AwaitExpression))
{
return;
}
if (!value.IsSingleLine())
{
return;
}
var switchStatement = (SwitchStatementSyntax)nextStatement;
ISymbol localSymbol = GetLocalSymbol(localDeclarationInfo, switchStatement.Expression, context.SemanticModel, context.CancellationToken);
if (localSymbol?.IsErrorType() != false)
{
return;
}
ContainsLocalOrParameterReferenceWalker walker = ContainsLocalOrParameterReferenceWalker.GetInstance(localSymbol, context.SemanticModel, context.CancellationToken);
walker.VisitList(switchStatement.Sections);
if (!walker.Result &&
index < statements.Count - 2)
{
walker.VisitList(statements, index + 2);
}
if (ContainsLocalOrParameterReferenceWalker.GetResultAndFree(walker))
{
return;
}
ReportDiagnostic(context, localDeclarationInfo, switchStatement.Expression);
break;
}
}
}
private static SyntaxList <AttributeListSyntax> FixRemappedAttributes(
SyntaxList <AttributeListSyntax> existingAttrList,
List <AttributeSyntax> remappedListAttributes)
{
return(FixRemappedAttributes(existingAttrList, remappedListAttributes, null));
}
private ImmutableArray <BoundPatternSwitchSection> BindPatternSwitchSections(BoundExpression boundSwitchExpression, SyntaxList <SwitchSectionSyntax> sections, Binder originalBinder, ref DefaultSwitchLabelSyntax defaultLabel, DiagnosticBag diagnostics)
{
// Bind match sections
var boundPatternSwitchSectionsBuilder = ArrayBuilder <BoundPatternSwitchSection> .GetInstance();
foreach (var sectionSyntax in sections)
{
boundPatternSwitchSectionsBuilder.Add(BindPatternSwitchSection(boundSwitchExpression, sectionSyntax, originalBinder, ref defaultLabel, diagnostics));
}
return(boundPatternSwitchSectionsBuilder.ToImmutableAndFree());
}
public StructDeclarationSyntax Update(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken keyword, SyntaxToken identifier, TypeParameterListSyntax typeParameterList, BaseListSyntax baseList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken openBraceToken, SyntaxList<MemberDeclarationSyntax> members, SyntaxToken closeBraceToken, SyntaxToken semicolonToken)
{
return this.Update(attributeLists, modifiers, keyword, identifier, typeParameterList, this.ParameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken);
}
public bool Equals(SyntaxList <TNode> other)
{
return(_node == other._node);
}
