Example #1
0
        public void Test0()
        {
            Expression expression = Expression.Not(Expression.Constant(true));

            ConditionalExpressionVisitor visitor = new ConditionalExpressionVisitor();

            Expression result = visitor.Visit(expression);

            Assert.IsType <ConstantExpression>(result);
            Assert.IsType <bool>(((ConstantExpression)result).Value);
            Assert.False((bool)((ConstantExpression)result).Value);
        }
Example #2
0
        public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax method)
        {
            var marked = ClassVirtualizationVisitor.MarkedForVirtualization(method);

            if (!marked.Item1)
            {
                return(method);
            }

            if (method.Body.DescendantNodes().OfType <StatementSyntax>().Count() <= METHOD_MIN_STATEMENTS)
            {
                return(method);
            }

            _virtualizationContext.Options = marked.Item2;
            var oldBody = method.Body;

            Debug.WriteLine("Method to be Refactored: " + method.Identifier);

            //WARNING: Do Not Change Order!
            var localDeclarationForceType = new LocalDeclarationConstantForceType(_virtualizationContext);

            // must be before: comparison simplifier, IF refactoring
            var switchConditionRefactoringVisitor = new SwitchConditionRefactoringVisitor();
            var switchSectionRefactoringVisitor   = new SwitchSectionRefactoringVisitor();
            var switchStatementRefactoringVisitor = new SwitchStatementRefactoringVisitor();

            var comparisonSignSimplifier           = new ComparisonSignSimplifierVisitor();
            var conditionalExpressionVisitor       = new ConditionalExpressionVisitor();
            var ifBranchRefactoringVisitor         = new IfBranchesRefactoringVisitor();
            var loopBodyRefactoringVisitor         = new LoopBodyRefactoringVisitor();
            var ifConditionRefactoringVisitor      = new IfConditionRefactoringVisitor();
            var forConditionRefactoringVisitor     = new ForConditionRefactoringVisitor();
            var whileConditionRefactoringVisitor   = new WhileConditionRefactoringVisitor();
            var doWhileConditionRefactoringVisitor = new DoWhileConditionRefactoringVisitor();
            var composedAssignmentVisitor          = new ComposedAssignmentVisitor();
            var prePostOperationVisitor            = new PrePostOperationVisitor();

            var tryCatchVisitor = new TryCatchRefactoringVisitor(_virtualizationContext);

            var parenthesisOperationVisitor    = new ParenthesisOperationSimplifierVisitor(_virtualizationContext);
            var multiplicativeOperationVisitor = new MultiplicativeOperationSimplifierVisitor(_virtualizationContext);
            var additiveOperationVisitor       = new AdditiveOperationSimplifierVisitor(_virtualizationContext);
            var invocationExpressionVisitor    = new InvocationExpressionSimplifier();
            var memberAccessExpresionVisitor   = new MemberAccessExpressionSimplifier();

            oldBody = (BlockSyntax)localDeclarationForceType.Refactor(oldBody);

            oldBody = (BlockSyntax)switchConditionRefactoringVisitor.Refactor(oldBody);
            oldBody = (BlockSyntax)switchSectionRefactoringVisitor.Refactor(oldBody);
            oldBody = (BlockSyntax)switchStatementRefactoringVisitor.Refactor(oldBody);

            //IF branch before condition
            oldBody = (BlockSyntax)conditionalExpressionVisitor.Visit(oldBody);
            oldBody = (BlockSyntax)comparisonSignSimplifier.Visit(oldBody);
            oldBody = (BlockSyntax)ifBranchRefactoringVisitor.Refactor(oldBody);
            oldBody = (BlockSyntax)ifConditionRefactoringVisitor.Refactor(oldBody);


            oldBody = (BlockSyntax)loopBodyRefactoringVisitor.Refactor(oldBody);
            //FOR before while!
            oldBody = (BlockSyntax)forConditionRefactoringVisitor.Refactor(oldBody);
            oldBody = (BlockSyntax)doWhileConditionRefactoringVisitor.Refactor(oldBody);
            oldBody = (BlockSyntax)whileConditionRefactoringVisitor.Refactor(oldBody);

            oldBody = (BlockSyntax)tryCatchVisitor.Visit(oldBody);

            oldBody = (BlockSyntax)composedAssignmentVisitor.Refactor(oldBody);
            oldBody = (BlockSyntax)parenthesisOperationVisitor.Refactor(oldBody);
            oldBody = (BlockSyntax)multiplicativeOperationVisitor.Refactor(oldBody);
            oldBody = (BlockSyntax)additiveOperationVisitor.Refactor(oldBody);


            oldBody = (BlockSyntax)prePostOperationVisitor.Refactor(oldBody);
            oldBody = (BlockSyntax)invocationExpressionVisitor.Refactor(oldBody);
            oldBody = (BlockSyntax)memberAccessExpresionVisitor.Refactor(oldBody);

            string returnType = method.ReturnType.ToString();

            if (returnType.Equals("void"))
            {
                oldBody = AddReturnToVoidMethod(oldBody);
            }


            var updatedMethod = method.ReplaceNode(method.Body, oldBody);

            //TODO: fix formatting
            //            oldBody = (BlockSyntax) Formatter.Format(oldBody, texts, VisualStudioSolutionHandler.workspace);
            updatedMethod = updatedMethod.NormalizeWhitespace().WithTriviaFrom(method);

//            Console.WriteLine("Method Refactored: " + method.Identifier);
            Debug.WriteLine("Method Refactored: " + method.Identifier);

            return(updatedMethod);
        }