codeql/python/ql/test/library-tests/ControlFlow/pruning/test.py at next · github/codeql · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
#Test number of CFG nodes for each use of 'count'

def dead():
    return 0
    count

def conditional_dead(test):
    if test:
        return
    if test:
        count

def made_true(seq):
    if seq:
        return
    seq.append(1)
    if seq:
        count

def boolop(t1, t2, t3, t4, t5, t6):
    if not t1:
        return
    #bool(t1) must be True
    t1 or count
    t1 and count
    if t2:
        return
    #bool(t2) must be False
    t2 or count
    t2 and count
    if t3 or t4:
        t3 or count
        t3 and count
        t3 or count
        t4 and count
    if t5 and t6:
        t5 or count
        t5 and count
        t6 or count
        t6 and count

def with_splitting(t1, t2):
    if t1:
        if not t2:
            return
    #Cannot have bool(t1) be True and bool(t2) be False
    if t1:
        t2 or count #Unreachable
        t2 and count
    else:
        t2 or count
        t2 and count

def loops(seq1, seq2, seq3, seq4, seq5):
    if seq1:
        return
    if not seq2:
        return
    #bool(seq1) is False; bool(seq2) is True
    while seq1:
        count #This is unreachable, but the pop below forces us to be conservative.
        seq1.pop()
    while seq2:
        count
        seq2.pop()
    if seq3:
        return
    if not seq4:
        return
    #bool(seq3) is False; bool(seq4) is True
    for var in seq3:
        count #This is unreachable, but we cannot infer this yet.
        print(var)
    for var in seq4:
        count
        print(var)
    #seq5 false then made true
    if seq5:
        return
    seq5.append(1)
    for var in seq5:
        count
        print(var)

#Logic does not apply to global variables in calls,
#as they may be changed from true to false externally.
from some_module import x, y
if not x:
    raise Exception()
if y:
    raise Exception()
make_a_call()
if not x:
    count
if y:
    count

# However, modules are always true -- Which is important.
import another_module

make_a_call()
if not another_module:
    count


def negated_conditional_live(t1, t2):
    if not t1:
        return
    if t2:
        return
    if t1:
        count
    if not t2:
        count

def negated_conditional_dead(test):
    if not test:
        return
    if not test:
        count

def made_true2(m):
    if m:
        return
    del m['a']
    if m:
        count

def prune_const_branches():
    if None:
        count
    if not None:
        count
    if False:
        count
    else:
        count
    if True:
        count
    else:
        count
    if 0:
        count
    else:
        count
    if -4:
        count
    else:
        count
    #Muliptle nots
    if not not False:
        count
    if not not not False:
        count

#ODASA-6794
def attribute_lookup_cannot_effect_comparisons_with_immutable_constants(ps):
    if ps is not None:
        ps_clamped = ps.clamp()
    if ps is None:
        count
    else:
        count