コード例 #1
0
            public override SyntaxList <StatementSyntax> VisitForEachBlock(VBSyntax.ForEachBlockSyntax node)
            {
                var stmt = node.ForEachStatement;

                TypeSyntax  type = null;
                SyntaxToken id;

                if (stmt.ControlVariable is VBSyntax.VariableDeclaratorSyntax)
                {
                    var v           = (VBSyntax.VariableDeclaratorSyntax)stmt.ControlVariable;
                    var declaration = VisualBasicConverter.SplitVariableDeclarations(v, _nodesVisitor, _semanticModel).Values.Single();
                    type = declaration.Type;
                    id   = declaration.Variables[0].Identifier;
                }
                else
                {
                    var v = (IdentifierNameSyntax)stmt.ControlVariable.Accept(_nodesVisitor);
                    id   = v.Identifier;
                    type = SyntaxFactory.ParseTypeName("var");
                }

                var block = SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(CommentConvertingVisitor)));

                return(SingleStatement(SyntaxFactory.ForEachStatement(
                                           type,
                                           id,
                                           (ExpressionSyntax)stmt.Expression.Accept(_nodesVisitor),
                                           block.UnpackNonNestedBlock()
                                           )));
            }
コード例 #2
0
        public async Task <Document> SingleFirstPass(Document document)
        {
            var converted = await VisualBasicConverter.ConvertCompilationTree(document, _csharpViewOfVbSymbols, _csharpReferenceProject);

            var convertedDocument = _convertedCsProject.AddDocument(document.FilePath, converted);

            _convertedCsProject = convertedDocument.Project;
            return(convertedDocument);
        }
コード例 #3
0
        public SyntaxTree SingleFirstPass(Compilation sourceCompilation, SyntaxTree tree)
        {
            _sourceCompilation = sourceCompilation;
            var converted     = VisualBasicConverter.ConvertCompilationTree((VisualBasicCompilation)sourceCompilation, (VisualBasicSyntaxTree)tree);
            var convertedTree = SyntaxFactory.SyntaxTree(converted);

            _firstPassResults.Add(convertedTree);
            return(convertedTree);
        }
コード例 #4
0
            public override SyntaxList <StatementSyntax> VisitLocalDeclarationStatement(VBSyntax.LocalDeclarationStatementSyntax node)
            {
                var modifiers = VisualBasicConverter.ConvertModifiers(node.Modifiers, TokenContext.Local);

                var declarations = new List <LocalDeclarationStatementSyntax>();

                foreach (var declarator in node.Declarators)
                {
                    foreach (var decl in VisualBasicConverter.SplitVariableDeclarations(declarator, _nodesVisitor, _semanticModel))
                    {
                        declarations.Add(SyntaxFactory.LocalDeclarationStatement(modifiers, decl.Value));
                    }
                }

                return(SyntaxFactory.List <StatementSyntax>(declarations));
            }
コード例 #5
0
            public override SyntaxList <StatementSyntax> VisitUsingBlock(VBSyntax.UsingBlockSyntax node)
            {
                var statementSyntax = SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(CommentConvertingVisitor)));

                if (node.UsingStatement.Expression == null)
                {
                    StatementSyntax stmt = statementSyntax;
                    foreach (var v in node.UsingStatement.Variables.Reverse())
                    {
                        foreach (var declaration in VisualBasicConverter.SplitVariableDeclarations(v, _nodesVisitor, _semanticModel).Values.Reverse())
                        {
                            stmt = SyntaxFactory.UsingStatement(declaration, null, stmt);
                        }
                    }
                    return(SingleStatement(stmt));
                }

                var expr = (ExpressionSyntax)node.UsingStatement.Expression.Accept(_nodesVisitor);
                var unpackPossiblyNestedBlock = statementSyntax.UnpackPossiblyNestedBlock(); // Allow reduced indentation for multiple usings in a row

                return(SingleStatement(SyntaxFactory.UsingStatement(null, expr, unpackPossiblyNestedBlock)));
            }
コード例 #6
0
            public override SyntaxList <StatementSyntax> VisitForBlock(VBSyntax.ForBlockSyntax node)
            {
                var stmt = node.ForStatement;
                ExpressionSyntax          startValue  = (ExpressionSyntax)stmt.FromValue.Accept(_nodesVisitor);
                VariableDeclarationSyntax declaration = null;
                ExpressionSyntax          id;

                if (stmt.ControlVariable is VBSyntax.VariableDeclaratorSyntax)
                {
                    var v = (VBSyntax.VariableDeclaratorSyntax)stmt.ControlVariable;
                    declaration = VisualBasicConverter.SplitVariableDeclarations(v, _nodesVisitor, _semanticModel).Values.Single();
                    declaration = declaration.WithVariables(SyntaxFactory.SingletonSeparatedList(declaration.Variables[0].WithInitializer(SyntaxFactory.EqualsValueClause(startValue))));
                    id          = SyntaxFactory.IdentifierName(declaration.Variables[0].Identifier);
                }
                else
                {
                    id = (ExpressionSyntax)stmt.ControlVariable.Accept(_nodesVisitor);
                    var symbol = _semanticModel.GetSymbolInfo(stmt.ControlVariable).Symbol;
                    if (!_semanticModel.LookupSymbols(node.FullSpan.Start, name: symbol.Name).Any())
                    {
                        var variableDeclaratorSyntax = SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(symbol.Name), null,
                                                                                        SyntaxFactory.EqualsValueClause(startValue));
                        declaration = SyntaxFactory.VariableDeclaration(
                            SyntaxFactory.IdentifierName("var"),
                            SyntaxFactory.SingletonSeparatedList(variableDeclaratorSyntax));
                    }
                    else
                    {
                        startValue = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, id, startValue);
                    }
                }

                var step = (ExpressionSyntax)stmt.StepClause?.StepValue.Accept(_nodesVisitor);
                PrefixUnaryExpressionSyntax value = step.SkipParens() as PrefixUnaryExpressionSyntax;
                ExpressionSyntax            condition;

                if (value == null)
                {
                    condition = SyntaxFactory.BinaryExpression(SyntaxKind.LessThanOrEqualExpression, id, (ExpressionSyntax)stmt.ToValue.Accept(_nodesVisitor));
                }
                else
                {
                    condition = SyntaxFactory.BinaryExpression(SyntaxKind.GreaterThanOrEqualExpression, id, (ExpressionSyntax)stmt.ToValue.Accept(_nodesVisitor));
                }
                if (step == null)
                {
                    step = SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostIncrementExpression, id);
                }
                else
                {
                    step = SyntaxFactory.AssignmentExpression(SyntaxKind.AddAssignmentExpression, id, step);
                }
                var block = SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(CommentConvertingVisitor)));

                return(SingleStatement(SyntaxFactory.ForStatement(
                                           declaration,
                                           declaration != null ? SyntaxFactory.SeparatedList <ExpressionSyntax>() : SyntaxFactory.SingletonSeparatedList(startValue),
                                           condition,
                                           SyntaxFactory.SingletonSeparatedList(step),
                                           block.UnpackNonNestedBlock())));
            }
コード例 #7
0
 public async Task <SyntaxNode> SingleFirstPass(Document document)
 {
     return(await VisualBasicConverter.ConvertCompilationTree(document, _csharpViewOfVbSymbols, _csharpReferenceProject));
 }
コード例 #8
0
 public async Task <SyntaxNode> SingleFirstPassAsync(Document document)
 {
     return(await VisualBasicConverter.ConvertCompilationTreeAsync(document, _csharpViewOfVbSymbols, _csharpReferenceProject, OptionalOperations, _typeToInheritors, _cancellationToken));
 }