Esempio n. 1
0
        private static async Task <Solution> Replace(
            Document document,
            AceSyntax node,
            CancellationToken cancellationToken)
        {
            var solution = document.Project.Solution;
            var root     = await document.GetSyntaxRootAsync(cancellationToken)
                           .ConfigureAwait(false);

            if (root is null)
            {
                return(solution);
            }
            var newSpecifiers = new[] { node.Type.RankSpecifiers.Last() };
            var newType       = SyntaxFactory.ArrayType(
                SyntaxFactory.OmittedTypeArgument(),
                SyntaxFactory.List(newSpecifiers));
            var newNode = node.WithType(newType);
            var newRoot = root.ReplaceNode(node, newNode);

            if (newRoot is null)
            {
                return(solution);
            }
            var workspace     = solution.Workspace;
            var formattedNode = Formatter.Format(
                newRoot,
                Formatter.Annotation,
                workspace,
                workspace.Options);

            return(solution.WithDocumentSyntaxRoot(
                       document.Id, formattedNode));
        }
Esempio n. 2
0
            public override VisualBasicSyntaxNode VisitArrayCreationExpression(CSS.ArrayCreationExpressionSyntax node)
            {
                var upperBoundArguments = node.Type.RankSpecifiers.First()?.Sizes.Where(s => !(s is CSS.OmittedArraySizeExpressionSyntax)).Select(
                    s => (ArgumentSyntax)SyntaxFactory.SimpleArgument(ReduceArrayUpperBoundExpression((ExpressionSyntax)s.Accept(this))));
                var rankSpecifiers = node.Type.RankSpecifiers.Select(rs => (ArrayRankSpecifierSyntax)rs.Accept(this));

                return(SyntaxFactory.ArrayCreationExpression(
                           SyntaxFactory.Token(SyntaxKind.NewKeyword),
                           SyntaxFactory.List <AttributeListSyntax>(),
                           (TypeSyntax)node.Type.ElementType.Accept(this),
                           upperBoundArguments.Any() ? SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList <ArgumentSyntax>(upperBoundArguments)) : null,
                           upperBoundArguments.Any() ? SyntaxFactory.List(rankSpecifiers.Skip(1)) : SyntaxFactory.List(rankSpecifiers),
                           (CollectionInitializerSyntax)node.Initializer?.Accept(this)
                           ));
            }