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.CSharpKind() == 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.CSharpKind())
{
case SyntaxKind.GetAccessorDeclaration:
implementfield = true;
newAccessors = newAccessors.Add(accessor.WithBody(SyntaxFactory.Block(SyntaxFactory.ReturnStatement(SyntaxFactory.IdentifierName("_" + prop.Identifier.ValueText)))));
break;
case SyntaxKind.SetAccessorDeclaration:
implementfield = true;
newAccessors = newAccessors.Add(accessor.WithBody(SyntaxFactory.Block(SyntaxFactory.ExpressionStatement(SyntaxFactory.BinaryExpression(SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.IdentifierName("_" + prop.Identifier.ValueText), SyntaxFactory.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(SyntaxFactory.VariableDeclarator("_" + prop.Identifier.ValueText));
newMembers = newMembers.Add(SyntaxFactory.FieldDeclaration(SyntaxFactory.VariableDeclaration(prop.Type, variables)).WithModifiers(prop.Modifiers));
}
newMembers = newMembers.Add(prop.WithAccessorList(prop.AccessorList.WithAccessors(newAccessors)));
}
else
{
newMembers = newMembers.Add(member);
}
}
return node.WithMembers(newMembers);
}
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
var emptyConstructor = SyntaxFactory.ConstructorDeclaration(node.Identifier.Text)
.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)))
.WithBody(SyntaxFactory.Block());
var insertIdx = 0;
if (node.Members.Any(p => p is FieldDeclarationSyntax))
{
insertIdx = node.Members.LastIndexOf(p => p is FieldDeclarationSyntax) + 1;
}
node = node.WithMembers(node.Members.Insert(insertIdx, emptyConstructor));
return base.VisitClassDeclaration(node);
}
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
//int indexers = node.Members.Count((m) => (m is IndexerDeclarationSyntax && !((IndexerDeclarationSyntax)m)));
SyntaxList<MemberDeclarationSyntax> members = SyntaxFactory.List<MemberDeclarationSyntax>();
int numIndexers = 0;
foreach (MemberDeclarationSyntax member in node.Members)
{
if (member.CSharpKind() == SyntaxKind.IndexerDeclaration)
{
IndexerDeclarationSyntax ids = (IndexerDeclarationSyntax)member;
numIndexers++;
foreach (AccessorDeclarationSyntax ads in ids.AccessorList.Accessors)
{
if (ads.Keyword.ToString() == "set")
{
members = members.Add(
SyntaxFactory.MethodDeclaration(ads.AttributeLists, ads.Modifiers.AddRange(ids.Modifiers), SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)), ids.ExplicitInterfaceSpecifier, SyntaxFactory.Identifier(ads.Keyword.ToString() + "_Item"), null, SyntaxFactory.ParameterList(ids.ParameterList.Parameters), SyntaxFactory.List<TypeParameterConstraintClauseSyntax>(), ads.Body)
);
}
else
{
members = members.Add(
SyntaxFactory.MethodDeclaration(ads.AttributeLists, ads.Modifiers.AddRange(ids.Modifiers), ids.Type, ids.ExplicitInterfaceSpecifier, SyntaxFactory.Identifier(ads.Keyword.ToString() + "_Item"), null, SyntaxFactory.ParameterList(ids.ParameterList.Parameters), SyntaxFactory.List<TypeParameterConstraintClauseSyntax>(), ads.Body)
);
}
}
}
else
{
members = members.Add(member);
}
}
if (numIndexers>0)
{
return node.WithMembers(members);
}
return base.VisitClassDeclaration(node);
}
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
var newName = "_" + this._relatedParam.Identifier.Text;
var newField = SyntaxFactory.FieldDeclaration(
SyntaxFactory.VariableDeclaration(
this._relatedParam.Type,
SyntaxFactory.SingletonSeparatedList<VariableDeclaratorSyntax>(
SyntaxFactory.VariableDeclarator(newName))))
.WithModifiers(SyntaxFactory.TokenList().Add(SyntaxFactory.Token(SyntaxKind.PrivateKeyword)));
this.GeneratedField = newField;
var insertIdx = 0;
if (node.Members.Any(p => p is FieldDeclarationSyntax))
{
insertIdx = node.Members.LastIndexOf(p => p is FieldDeclarationSyntax) + 1;
}
node = node.WithMembers(node.Members.Insert(insertIdx, newField));
return base.VisitClassDeclaration(node);
}
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node) {
if (node == this.type) {
return node.WithMembers(node.Members.Add(this.pre));
}
return base.VisitClassDeclaration(node);
}
private static ClassDeclarationSyntax SortMembers(ClassDeclarationSyntax type)
{
var innerMembers = type.Members.ToList();
innerMembers.Sort(StyleCop.Sort);
type = type.WithMembers(SyntaxFactory.List(innerMembers));
return type;
}
//public SemanticModel Model { get; private set; }
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
node = (ClassDeclarationSyntax)base.VisitClassDeclaration(node);
MethodDeclarationSyntax prector = SyntaxFactory.MethodDeclaration(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)), ".prector");
MethodDeclarationSyntax precctor = SyntaxFactory.MethodDeclaration(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)), ".precctor");
precctor = precctor.AddModifiers(SyntaxFactory.Token(SyntaxKind.StaticKeyword));
List<StatementSyntax> Initializers = new List<StatementSyntax>();
List<StatementSyntax> StaticInitializers = new List<StatementSyntax>();
foreach (MemberDeclarationSyntax member in node.Members)
{
if (member.CSharpKind() == SyntaxKind.FieldDeclaration)
{
FieldDeclarationSyntax fds = (FieldDeclarationSyntax)member;
foreach (VariableDeclaratorSyntax vds in fds.Declaration.Variables)
{
if (vds.Initializer != null)
{
if (fds.Modifiers.ToString().Contains("static"))
{
StaticInitializers.Add(SyntaxFactory.ExpressionStatement(SyntaxFactory.BinaryExpression(SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.IdentifierName(vds.Identifier), vds.Initializer.Value)));
}
else
{
Initializers.Add(SyntaxFactory.ExpressionStatement(SyntaxFactory.BinaryExpression(SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.IdentifierName(vds.Identifier), vds.Initializer.Value)));
}
}
}
}
}
if (Initializers.Count == 0 && StaticInitializers.Count == 0)
return node;
SyntaxList<MemberDeclarationSyntax> newMembers = new SyntaxList<MemberDeclarationSyntax>();
if (Initializers.Count > 0)
{
int constructors = node.Members.Count((m) => (m is ConstructorDeclarationSyntax && !((ConstructorDeclarationSyntax)m).Modifiers.ToString().Contains("static")));
prector = prector.AddBodyStatements(Initializers.ToArray());
node = node.AddMembers(prector);
if (constructors == 0)
{
ConstructorDeclarationSyntax ctor = SyntaxFactory.ConstructorDeclaration(node.Identifier);
ctor = ctor.AddBodyStatements(SyntaxFactory.ExpressionStatement(SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName(".prector"))));
ctor = ctor.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
newMembers = newMembers.Add(ctor);
}
// else
{
foreach (MemberDeclarationSyntax member in node.Members)
{
if (member.CSharpKind() == SyntaxKind.ConstructorDeclaration && !((ConstructorDeclarationSyntax)member).Modifiers.ToString().Contains("static"))
{
newMembers = newMembers.Add((MemberDeclarationSyntax)ConstructorPrefixerDeclaration((ConstructorDeclarationSyntax)member));
}
else
{
newMembers = newMembers.Add(member);
}
}
}
}
if (StaticInitializers.Count > 0)
{
int constructors = node.Members.Count((m) => (m is ConstructorDeclarationSyntax && ((ConstructorDeclarationSyntax)m).Modifiers.ToString().Contains("static")));
precctor = precctor.AddBodyStatements(StaticInitializers.ToArray());
node = node.AddMembers(precctor);
if (constructors == 0)
{
ConstructorDeclarationSyntax ctor = SyntaxFactory.ConstructorDeclaration(node.Identifier);
ctor = ctor.AddModifiers(SyntaxFactory.Token(SyntaxKind.StaticKeyword));
ctor = ctor.AddBodyStatements(SyntaxFactory.ExpressionStatement(SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName(".precctor"))));
ctor = ctor.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
newMembers = newMembers.Add(ctor);
}
//else
{
foreach (MemberDeclarationSyntax member in node.Members)
{
if (member.CSharpKind() == SyntaxKind.ConstructorDeclaration && ((ConstructorDeclarationSyntax)member).Modifiers.ToString().Contains("static"))
{
newMembers = newMembers.Add((MemberDeclarationSyntax)StaticConstructorPrefixerDeclaration((ConstructorDeclarationSyntax)member));
}
else
{
newMembers = newMembers.Add(member);
}
}
}
}
return node.WithMembers(newMembers);
}
