Exemplo n.º 1
0
        public override SyntaxNode VisitConstructorDeclaration(ConstructorDeclarationSyntax constructorDeclaration)
        {
            if (constructor == constructorDeclaration)
            {
                var    type      = field.Declaration.Type;
                var    variable  = RoslynExtensions.GetFieldName(field);
                string parameter = variable;

                if (variable.StartsWith("_"))
                {
                    parameter = variable.Substring(1);
                }
                else
                {
                    variable = "this." + variable;
                }

                //var typeString = type.ToString();
                //if (typeString.StartsWith("I"))
                //name = typeString.Substring(1);

                //name = Char.ToLowerInvariant(name[0]) + name.Substring(1);
                var p = SyntaxFactory.Parameter(
                    new SyntaxList <AttributeListSyntax>(),
                    new SyntaxTokenList(),
                    type,
                    SyntaxFactory.Identifier(parameter),
                    null);

                var parameters = constructorDeclaration.ParameterList.AddParameters(p);
                var body       = constructorDeclaration.Body;
                var statement  = SyntaxFactory.ParseStatement(variable + " = " + parameter + ";" + Environment.NewLine);//.WithLeadingTrivia(SyntaxFactory.Tab, SyntaxFactory.Tab);
                body = body.AddStatements(statement);

                return(constructorDeclaration.WithParameterList(parameters).WithBody(body)); //(BlockSyntax)formatted);
            }

            return(base.VisitConstructorDeclaration(constructorDeclaration));
        }
        private async Task <Document> Initialize(Document document, FieldDeclarationSyntax localDeclaration,
                                                 CancellationToken cancellationToken)
        {
            var tree = await document.GetSyntaxTreeAsync(cancellationToken);

            var root         = tree.GetRoot(cancellationToken);
            var constructors = root.DescendantNodes().OfType <ConstructorDeclarationSyntax>().ToList();
            var csor         = constructors.FirstOrDefault();



            SyntaxNode visitingRoot = root;

            if (csor == null)
            {
                var oldClass  = localDeclaration.FirstAncestorOrSelf <ClassDeclarationSyntax>();
                var className = oldClass.Identifier.ToString();

                var paramList = RoslynExtensions.GenerateParameters(new[] { localDeclaration.Declaration.Type });

                var newCtor = SyntaxFactory.ConstructorDeclaration(
                    attributeLists: SyntaxFactory.List(new AttributeListSyntax[] { }),
                    modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)),
                    identifier: oldClass.Identifier,
                    parameterList: paramList,
                    initializer: null,
                    body: SyntaxFactory.Block(new[] { RoslynExtensions.GenerateCtorStatement(RoslynExtensions.GetFieldName(localDeclaration), RoslynExtensions.GetFieldVariableName(localDeclaration.Declaration.Type)) }),
                    semicolonToken: default(SyntaxToken)
                    );

                csor = newCtor;

                visitingRoot = root.InsertNodesAfter(localDeclaration, new[] { newCtor });
            }

            var cr      = new ConstructorRewriter(csor, localDeclaration);
            var newRoot = cr.Visit(visitingRoot).WithAdditionalAnnotations(Formatter.Annotation);

            //var workspace = MSBuildWorkspace.Create();
            //var formatted = Formatter.Format(newRoot, workspace);

            return(document.WithSyntaxRoot(newRoot));
        }