public void TestIsInstance()
        {
            Assert.False(VariableDesignationSyntaxWrapper.IsInstance(null));
            Assert.False(VariableDesignationSyntaxWrapper.IsInstance(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));

            var discardDesignationSyntax = SyntaxFactory.DiscardDesignation();

            Assert.True(VariableDesignationSyntaxWrapper.IsInstance(discardDesignationSyntax));
        }
        public void TestConversions()
        {
            var syntaxNode = SyntaxFactory.DiscardDesignation();
            var discardDesignationSyntax = (DiscardDesignationSyntaxWrapper)syntaxNode;

            VariableDesignationSyntaxWrapper variableDesignationSyntax = discardDesignationSyntax;

            Assert.Same(syntaxNode, variableDesignationSyntax.SyntaxNode);

            discardDesignationSyntax = (DiscardDesignationSyntaxWrapper)variableDesignationSyntax;
            Assert.Same(syntaxNode, discardDesignationSyntax.SyntaxNode);

            SyntaxNode syntax = discardDesignationSyntax;

            Assert.Same(syntaxNode, syntax);
        }
        public void TestConversionsNull()
        {
            var syntaxNode = default(SyntaxNode);
            var discardDesignationSyntax = (DiscardDesignationSyntaxWrapper)syntaxNode;

            VariableDesignationSyntaxWrapper variableDesignationSyntax = discardDesignationSyntax;

            Assert.Null(variableDesignationSyntax.SyntaxNode);

            discardDesignationSyntax = (DiscardDesignationSyntaxWrapper)variableDesignationSyntax;
            Assert.Null(discardDesignationSyntax.SyntaxNode);

            SyntaxNode syntax = discardDesignationSyntax;

            Assert.Null(syntax);
        }
        public void TestConversionsNull()
        {
            var syntaxNode = default(SyntaxNode);
            var parenthesizedVariableDesignationSyntax = (ParenthesizedVariableDesignationSyntaxWrapper)syntaxNode;

            VariableDesignationSyntaxWrapper variableDesignationSyntax = parenthesizedVariableDesignationSyntax;

            Assert.Null(variableDesignationSyntax.SyntaxNode);

            parenthesizedVariableDesignationSyntax = (ParenthesizedVariableDesignationSyntaxWrapper)variableDesignationSyntax;
            Assert.Null(parenthesizedVariableDesignationSyntax.SyntaxNode);

            SyntaxNode syntax = parenthesizedVariableDesignationSyntax;

            Assert.Null(syntax);
        }
        public void TestConversions()
        {
            var syntaxNode = SyntaxFactory.ParenthesizedVariableDesignation();
            var parenthesizedVariableDesignationSyntax = (ParenthesizedVariableDesignationSyntaxWrapper)syntaxNode;

            VariableDesignationSyntaxWrapper variableDesignationSyntax = parenthesizedVariableDesignationSyntax;

            Assert.Same(syntaxNode, variableDesignationSyntax.SyntaxNode);

            parenthesizedVariableDesignationSyntax = (ParenthesizedVariableDesignationSyntaxWrapper)variableDesignationSyntax;
            Assert.Same(syntaxNode, parenthesizedVariableDesignationSyntax.SyntaxNode);

            SyntaxNode syntax = parenthesizedVariableDesignationSyntax;

            Assert.Same(syntaxNode, syntax);
        }
        public void TestConversionsNull()
        {
            var syntaxNode = default(SyntaxNode);
            var singleVariableDesignationSyntax = (SingleVariableDesignationSyntaxWrapper)syntaxNode;

            VariableDesignationSyntaxWrapper variableDesignationSyntax = singleVariableDesignationSyntax;

            Assert.Null(variableDesignationSyntax.SyntaxNode);

            singleVariableDesignationSyntax = (SingleVariableDesignationSyntaxWrapper)variableDesignationSyntax;
            Assert.Null(singleVariableDesignationSyntax.SyntaxNode);

            SyntaxNode syntax = singleVariableDesignationSyntax;

            Assert.Null(syntax);
        }
Exemple #7
0
        public void TestConversions()
        {
            var syntaxNode = SyntaxFactory.SingleVariableDesignation(SyntaxFactory.Identifier("Anything"));
            var singleVariableDesignationSyntax = (SingleVariableDesignationSyntaxWrapper)syntaxNode;

            VariableDesignationSyntaxWrapper variableDesignationSyntax = singleVariableDesignationSyntax;

            Assert.Same(syntaxNode, variableDesignationSyntax.SyntaxNode);

            singleVariableDesignationSyntax = (SingleVariableDesignationSyntaxWrapper)variableDesignationSyntax;
            Assert.Same(syntaxNode, singleVariableDesignationSyntax.SyntaxNode);

            SyntaxNode syntax = singleVariableDesignationSyntax;

            Assert.Same(syntaxNode, syntax);
        }
        private ProgramState VisitVariableDesignation(VariableDesignationSyntaxWrapper variableDesignation, ProgramState programState, bool singleVariable)
        {
            var newProgramState = programState;

            if (DiscardDesignationSyntaxWrapper.IsInstance(variableDesignation))
            {
                // Push value for the discard, it will be popped when visiting the block for the
                // corresponding case statement.
                newProgramState = newProgramState.PushValue(SymbolicValue.Create());
            }
            else if (SingleVariableDesignationSyntaxWrapper.IsInstance(variableDesignation))
            {
                // "x is string s" is equivalent to "s = x"; both symbolic values should remain on stack
                var singleVariableDesignation = (SingleVariableDesignationSyntaxWrapper)variableDesignation;

                // associate variable with new SV
                var variableSymbol   = SemanticModel.GetDeclaredSymbol(singleVariableDesignation);
                var newSymbolicValue = SymbolicValue.Create();
                newProgramState = SetNewSymbolicValueIfTracked(variableSymbol, newSymbolicValue, newProgramState);

                if (singleVariable)
                {
                    // When the pattern is "x is Type t" we know that "t != null", hence (SV != null)
                    newProgramState = newProgramState.PushValue(new ValueNotEqualsSymbolicValue(newSymbolicValue, SymbolicValue.Null));
                }
            }
            else if (ParenthesizedVariableDesignationSyntaxWrapper.IsInstance(variableDesignation))
            {
                var parenthesizedVariableDesignation = (ParenthesizedVariableDesignationSyntaxWrapper)variableDesignation;
                foreach (var variable in parenthesizedVariableDesignation.Variables)
                {
                    // the variables in the deconstruction should not receive "Not Null" constraint
                    newProgramState = VisitVariableDesignation(variable, newProgramState, singleVariable: false);
                }
            }
            else
            {
                throw new NotSupportedException($"{variableDesignation.SyntaxNode.Kind()}");
            }
            return(newProgramState);
        }