@samitouri / QOS-React-2 / commits / e248534184

[rust] SSA fixes after operand refactor

When updating the data model for operands from instruction indices to identifiers, I forgot to rewrite terminal operands.Doing so required a refactor to use the new BlockRewriter helper.

Joe Savona committed Aug 14, 2023 at 09:54 UTC e2485341846fec767f68b5c7c25b277699962054
17 files changed +371 -376
compiler/forget/crates/forget_fixtures/tests/fixtures/simple-ssa.js new
+9
@@ -0,0 +1,9 @@
1 +function Component(props) {
2 + let a;
3 + if (props) {
4 + a = 1;
5 + } else {
6 + a = 2;
7 + }
8 + return a;
9 +}
compiler/forget/crates/forget_fixtures/tests/fixtures_test.rs
-1
@@ -38,7 +38,6 @@ fn fixtures() {
38 match build(&environment, &fun.function) {
39 Ok(mut fun) => {
40 println!("ok build");
41 - fun.debug();
41 enter_ssa(&environment, &mut fun).unwrap();
42 println!("ok enter_ssa");
43 eliminate_redundant_phis(&environment, &mut fun);
compiler/forget/crates/forget_fixtures/tests/snapshots/fixtures_test__fixtures@constant-propagation-constant-if-condition.js.snap
+24 -68
@@ -46,72 +46,28 @@ function Component(
46 entry bb0
47 bb0 (block)
48 [0] unknown $39 = 1
49 - [1] unknown $40 = StoreLocal Let unknown a$41 = unknown $39
50 - [2] unknown $42 = DeclareLocal Let unknown b$43
51 - [3] unknown $44 = LoadLocal unknown a$1
49 + [1] unknown $41 = StoreLocal Let unknown a$40 = unknown $39
50 + [2] unknown $43 = DeclareLocal Let unknown b$42
51 + [3] unknown $44 = 1
52 [4] unknown $45 = 1
53 - [5] unknown $46 = Binary unknown $44 === unknown $45
54 - [6] If unknown $11 consequent=bb2 alternate=bb3 fallthrough=bb1
55 -bb2 (block)
56 - predecessors: bb0
57 - [7] unknown $47 = true
58 - [8] unknown $48 = StoreLocal Reassign unknown b$49 = unknown $47
59 - [9] Goto bb1
60 -bb3 (block)
61 - predecessors: bb0
62 - [10] unknown $50 = false
63 - [11] unknown $51 = StoreLocal Reassign unknown b$52 = unknown $50
64 - [12] Goto bb1
65 -bb1 (block)
66 - predecessors: bb2, bb3
67 - [13] unknown $53 = DeclareLocal Let unknown c$54
68 - [14] unknown $55 = LoadLocal unknown b$3
69 - [15] If unknown $18 consequent=bb5 alternate=bb6 fallthrough=bb4
70 -bb5 (block)
71 - predecessors: bb1
72 - [16] unknown $56 = "hello"
73 - [17] unknown $57 = StoreLocal Reassign unknown c$58 = unknown $56
74 - [18] Goto bb4
75 -bb6 (block)
76 - predecessors: bb1
77 - [19] unknown $59 = null
78 - [20] unknown $60 = StoreLocal Reassign unknown c$61 = unknown $59
79 - [21] Goto bb4
80 -bb4 (block)
81 - predecessors: bb5, bb6
82 - [22] unknown $62 = DeclareLocal Let unknown d$63
83 - [23] unknown $64 = LoadLocal unknown c$12
84 - [24] unknown $65 = "hello"
85 - [25] unknown $66 = Binary unknown $64 === unknown $65
86 - [26] If unknown $27 consequent=bb8 alternate=bb9 fallthrough=bb7
87 -bb8 (block)
88 - predecessors: bb4
89 - [27] unknown $67 = 42
90 - [28] unknown $68 = StoreLocal Reassign unknown d$69 = unknown $67
91 - [29] Goto bb7
92 -bb9 (block)
93 - predecessors: bb4
94 - [30] unknown $70 = 42.001
95 - [31] unknown $71 = StoreLocal Reassign unknown d$72 = unknown $70
96 - [32] Goto bb7
97 -bb7 (block)
98 - predecessors: bb8, bb9
99 - [33] unknown $73 = DeclareLocal Let unknown e$74
100 - [34] unknown $75 = LoadLocal unknown d$19
101 - [35] unknown $76 = 42
102 - [36] unknown $77 = Binary unknown $75 === unknown $76
103 - [37] If unknown $36 consequent=bb11 alternate=bb12 fallthrough=bb10
104 -bb11 (block)
105 - predecessors: bb7
106 - [38] unknown $78 = "ok"
107 - [39] unknown $79 = StoreLocal Reassign unknown e$80 = unknown $78
108 - [40] Goto bb10
109 -bb12 (block)
110 - predecessors: bb7
111 - [41] unknown $81 = "nope"
112 - [42] unknown $82 = StoreLocal Reassign unknown e$83 = unknown $81
113 - [43] Goto bb10
114 -bb10 (block)
115 - predecessors: bb11, bb12
116 - [44] unknown $84 = LoadLocal unknown e$28
117 - [45] Return unknown $37
53 + [5] unknown $46 = true
54 + [6] unknown $47 = true
55 + [7] unknown $49 = StoreLocal Reassign unknown b$48 = unknown $47
56 + [8] unknown $54 = DeclareLocal Let unknown c$53
57 + [9] unknown $56 = true
58 + [10] unknown $57 = "hello"
59 + [11] unknown $59 = StoreLocal Reassign unknown c$58 = unknown $57
60 + [12] unknown $64 = DeclareLocal Let unknown d$63
61 + [13] unknown $66 = "hello"
62 + [14] unknown $67 = "hello"
63 + [15] unknown $68 = true
64 + [16] unknown $69 = 42
65 + [17] unknown $71 = StoreLocal Reassign unknown d$70 = unknown $69
66 + [18] unknown $76 = DeclareLocal Let unknown e$75
67 + [19] unknown $78 = 42
68 + [20] unknown $79 = 42
69 + [21] unknown $80 = true
70 + [22] unknown $81 = "ok"
71 + [23] unknown $83 = StoreLocal Reassign unknown e$82 = unknown $81
72 + [24] unknown $88 = "ok"
73 + [25] Return unknown $88
compiler/forget/crates/forget_fixtures/tests/snapshots/fixtures_test__fixtures@constant-propagation.js.snap
+105 -103
@@ -72,125 +72,127 @@ function Component(
72 )
73 entry bb0
74 bb0 (block)
75 - [0] unknown $109 = DeclareLocal Let unknown a$110
75 + [0] unknown $110 = DeclareLocal Let unknown a$109
76 [1] unknown $111 = LoadGlobal Math
77 - [2] unknown $112 = StoreLocal Reassign unknown a$113 = unknown $111
78 - [3] unknown $114 = LoadLocal unknown a$1
79 - [4] unknown $115 = DeclareLocal Let unknown b$116
80 - [5] unknown $117 = LoadLocal unknown props$0
81 - [6] If unknown $12 consequent=bb2 alternate=bb3 fallthrough=bb1
77 + [2] unknown $113 = StoreLocal Reassign unknown a$112 = unknown $111
78 + [3] unknown $114 = LoadGlobal Math
79 + [4] unknown $116 = DeclareLocal Let unknown b$115
80 + [5] unknown $117 = LoadLocal unknown props$108
81 + [6] If unknown $117 consequent=bb2 alternate=bb3 fallthrough=bb1
82 bb2 (block)
83 predecessors: bb0
84 [7] unknown $118 = true
85 - [8] unknown $119 = StoreLocal Reassign unknown b$120 = unknown $118
85 + [8] unknown $120 = StoreLocal Reassign unknown b$119 = unknown $118
86 [9] Goto bb1
87 bb3 (block)
88 predecessors: bb0
89 [10] unknown $121 = true
90 - [11] unknown $122 = StoreLocal Reassign unknown b$123 = unknown $121
90 + [11] unknown $123 = StoreLocal Reassign unknown b$122 = unknown $121
91 [12] Goto bb1
92 bb1 (block)
93 predecessors: bb2, bb3
94 - [13] unknown $124 = LoadLocal unknown b$6
95 - [14] unknown $125 = DeclareLocal Let unknown c$126
96 - [15] unknown $127 = LoadLocal unknown props$0
97 - [16] If unknown $20 consequent=bb5 alternate=bb6 fallthrough=bb4
94 + b$124: phi(bb2: b$119, bb3: b$122)
95 + [13] unknown $125 = true
96 + [14] unknown $127 = DeclareLocal Let unknown c$126
97 + [15] unknown $129 = LoadLocal unknown props$108
98 + [16] If unknown $129 consequent=bb5 alternate=bb6 fallthrough=bb4
99 bb5 (block)
100 predecessors: bb1
100 - [17] unknown $128 = true
101 - [18] unknown $129 = StoreLocal Reassign unknown c$130 = unknown $128
101 + [17] unknown $130 = true
102 + [18] unknown $132 = StoreLocal Reassign unknown c$131 = unknown $130
103 [19] Goto bb4
104 bb6 (block)
105 predecessors: bb1
105 - [20] unknown $131 = 42
106 - [21] unknown $132 = StoreLocal Reassign unknown c$133 = unknown $131
106 + [20] unknown $133 = 42
107 + [21] unknown $135 = StoreLocal Reassign unknown c$134 = unknown $133
108 [22] Goto bb4
109 bb4 (block)
110 predecessors: bb5, bb6
110 - [23] unknown $134 = LoadLocal unknown c$14
111 - [24] unknown $135 = 42
112 - [25] unknown $136 = 1
113 - [26] unknown $137 = 43
114 - [27] unknown $138 = 42
115 - [28] unknown $139 = 1
116 - [29] unknown $140 = 41
117 - [30] unknown $141 = 42
118 - [31] unknown $142 = 2
119 - [32] unknown $143 = 84
120 - [33] unknown $144 = 42
121 - [34] unknown $145 = 2
122 - [35] unknown $146 = 21
123 - [36] unknown $147 = 0
124 - [37] unknown $148 = 1
125 - [38] unknown $149 = false
126 - [39] unknown $150 = 0
127 - [40] unknown $151 = 1
128 - [41] unknown $152 = true
129 - [42] unknown $153 = 0
130 - [43] unknown $154 = 1
131 - [44] unknown $155 = false
132 - [45] unknown $156 = 0
133 - [46] unknown $157 = 1
134 - [47] unknown $158 = true
135 - [48] unknown $159 = 0
136 - [49] unknown $160 = 0
137 - [50] unknown $161 = true
138 - [51] unknown $162 = LoadGlobal NaN
139 - [52] unknown $163 = LoadGlobal NaN
140 - [53] unknown $164 = Binary unknown $162 == unknown $163
141 - [54] unknown $165 = LoadGlobal NaN
142 - [55] unknown $166 = LoadGlobal NaN
143 - [56] unknown $167 = Binary unknown $165 != unknown $166
144 - [57] unknown $168 = LoadGlobal NaN
145 - [58] unknown $169 = LoadGlobal NaN
146 - [59] unknown $170 = Binary unknown $168 !== unknown $169
147 - [60] unknown $171 = LoadGlobal NaN
148 - [61] unknown $172 = LoadGlobal NaN
149 - [62] unknown $173 = Binary unknown $171 !== unknown $172
150 - [63] unknown $174 = "hello"
151 - [64] unknown $175 = "hello"
152 - [65] unknown $176 = true
153 - [66] unknown $177 = "hello"
154 - [67] unknown $178 = "hello"
155 - [68] unknown $179 = false
156 - [69] unknown $180 = "hello"
157 - [70] unknown $181 = "hello"
158 - [71] unknown $182 = true
159 - [72] unknown $183 = "hello"
160 - [73] unknown $184 = "hello"
161 - [74] unknown $185 = false
162 - [75] unknown $186 = "hello"
163 - [76] unknown $187 = "world"
164 - [77] unknown $188 = false
165 - [78] unknown $189 = "hello"
166 - [79] unknown $190 = "world"
167 - [80] unknown $191 = true
168 - [81] unknown $192 = "hello"
169 - [82] unknown $193 = "world"
170 - [83] unknown $194 = false
171 - [84] unknown $195 = "hello"
172 - [85] unknown $196 = "world"
173 - [86] unknown $197 = true
174 - [87] unknown $198 = true
175 - [88] unknown $199 = true
176 - [89] unknown $200 = true
177 - [90] unknown $201 = true
178 - [91] unknown $202 = true
179 - [92] unknown $203 = false
180 - [93] unknown $204 = true
181 - [94] unknown $205 = true
182 - [95] unknown $206 = true
183 - [96] unknown $207 = true
184 - [97] unknown $208 = true
185 - [98] unknown $209 = false
186 - [99] unknown $210 = 5
187 - [100] unknown $211 = 60
188 - [101] unknown $212 = 300
189 - [102] unknown $213 = 60
190 - [103] unknown $214 = 18000
191 - [104] unknown $215 = 1000
192 - [105] unknown $216 = 18000000
193 - [106] unknown $217 = StoreLocal Let unknown x$218 = unknown $216
194 - [107] unknown $219 = LoadLocal unknown x$104
195 - [108] unknown $220 = <undefined>
196 - [109] Return unknown $107
111 + c$136: phi(bb5: c$131, bb6: c$134)
112 + [23] unknown $137 = LoadLocal unknown c$136
113 + [24] unknown $138 = 42
114 + [25] unknown $139 = 1
115 + [26] unknown $140 = 43
116 + [27] unknown $141 = 42
117 + [28] unknown $142 = 1
118 + [29] unknown $143 = 41
119 + [30] unknown $144 = 42
120 + [31] unknown $145 = 2
121 + [32] unknown $146 = 84
122 + [33] unknown $147 = 42
123 + [34] unknown $148 = 2
124 + [35] unknown $149 = 21
125 + [36] unknown $150 = 0
126 + [37] unknown $151 = 1
127 + [38] unknown $152 = false
128 + [39] unknown $153 = 0
129 + [40] unknown $154 = 1
130 + [41] unknown $155 = true
131 + [42] unknown $156 = 0
132 + [43] unknown $157 = 1
133 + [44] unknown $158 = false
134 + [45] unknown $159 = 0
135 + [46] unknown $160 = 1
136 + [47] unknown $161 = true
137 + [48] unknown $162 = 0
138 + [49] unknown $163 = 0
139 + [50] unknown $164 = true
140 + [51] unknown $165 = LoadGlobal NaN
141 + [52] unknown $166 = LoadGlobal NaN
142 + [53] unknown $167 = Binary unknown $165 == unknown $166
143 + [54] unknown $168 = LoadGlobal NaN
144 + [55] unknown $169 = LoadGlobal NaN
145 + [56] unknown $170 = Binary unknown $168 != unknown $169
146 + [57] unknown $171 = LoadGlobal NaN
147 + [58] unknown $172 = LoadGlobal NaN
148 + [59] unknown $173 = Binary unknown $171 !== unknown $172
149 + [60] unknown $174 = LoadGlobal NaN
150 + [61] unknown $175 = LoadGlobal NaN
151 + [62] unknown $176 = Binary unknown $174 !== unknown $175
152 + [63] unknown $177 = "hello"
153 + [64] unknown $178 = "hello"
154 + [65] unknown $179 = true
155 + [66] unknown $180 = "hello"
156 + [67] unknown $181 = "hello"
157 + [68] unknown $182 = false
158 + [69] unknown $183 = "hello"
159 + [70] unknown $184 = "hello"
160 + [71] unknown $185 = true
161 + [72] unknown $186 = "hello"
162 + [73] unknown $187 = "hello"
163 + [74] unknown $188 = false
164 + [75] unknown $189 = "hello"
165 + [76] unknown $190 = "world"
166 + [77] unknown $191 = false
167 + [78] unknown $192 = "hello"
168 + [79] unknown $193 = "world"
169 + [80] unknown $194 = true
170 + [81] unknown $195 = "hello"
171 + [82] unknown $196 = "world"
172 + [83] unknown $197 = false
173 + [84] unknown $198 = "hello"
174 + [85] unknown $199 = "world"
175 + [86] unknown $200 = true
176 + [87] unknown $201 = true
177 + [88] unknown $202 = true
178 + [89] unknown $203 = true
179 + [90] unknown $204 = true
180 + [91] unknown $205 = true
181 + [92] unknown $206 = false
182 + [93] unknown $207 = true
183 + [94] unknown $208 = true
184 + [95] unknown $209 = true
185 + [96] unknown $210 = true
186 + [97] unknown $211 = true
187 + [98] unknown $212 = false
188 + [99] unknown $213 = 5
189 + [100] unknown $214 = 60
190 + [101] unknown $215 = 300
191 + [102] unknown $216 = 60
192 + [103] unknown $217 = 18000
193 + [104] unknown $218 = 1000
194 + [105] unknown $219 = 18000000
195 + [106] unknown $221 = StoreLocal Let unknown x$220 = unknown $219
196 + [107] unknown $222 = 18000000
197 + [108] unknown $223 = <undefined>
198 + [109] Return unknown $223
compiler/forget/crates/forget_fixtures/tests/snapshots/fixtures_test__fixtures@destructure-array.js.snap
+12 -12
@@ -18,16 +18,16 @@ function Component(
18 )
19 entry bb0
20 bb0 (block)
21 - [0] unknown $24 = LoadLocal unknown a$0
22 - [1] unknown $25 = Destructure [ unknown c$26, <hole>, ...unknown d$27 ] = unknown $24
23 - [2] unknown $28 = LoadLocal unknown b$1
24 - [3] unknown $29 = Destructure [ unknown $30, ...unknown $31 ] = unknown $28
25 - [4] unknown $32 = Destructure [ unknown $33 ] = unknown $30
26 - [5] unknown $34 = Destructure [ unknown e$35 ] = unknown $33
27 - [6] unknown $36 = Destructure [ unknown f$37 ] = unknown $31
28 - [7] unknown $38 = LoadLocal unknown c$3
29 - [8] unknown $39 = LoadLocal unknown d$4
30 - [9] unknown $40 = LoadLocal unknown e$12
31 - [10] unknown $41 = LoadLocal unknown f$14
21 + [0] unknown $24 = LoadLocal unknown a$22
22 + [1] unknown $27 = Destructure [ unknown c$25, <hole>, ...unknown d$26 ] = unknown $24
23 + [2] unknown $28 = LoadLocal unknown b$23
24 + [3] unknown $31 = Destructure [ unknown $29, ...unknown $30 ] = unknown $28
25 + [4] unknown $33 = Destructure [ unknown $32 ] = unknown $29
26 + [5] unknown $35 = Destructure [ unknown e$34 ] = unknown $32
27 + [6] unknown $37 = Destructure [ unknown f$36 ] = unknown $30
28 + [7] unknown $38 = LoadLocal unknown c$25
29 + [8] unknown $39 = LoadLocal unknown d$26
30 + [9] unknown $40 = LoadLocal unknown e$34
31 + [10] unknown $41 = LoadLocal unknown f$36
32 [11] unknown $42 = Array [unknown $38, unknown $39, unknown $40, unknown $41]
33 - [12] Return unknown $20
33 + [12] Return unknown $42
compiler/forget/crates/forget_fixtures/tests/snapshots/fixtures_test__fixtures@destructure-object.js.snap
+15 -15
@@ -28,19 +28,19 @@ function Component(
28 )
29 entry bb0
30 bb0 (block)
31 - [0] unknown $32 = LoadLocal unknown a$0
32 - [1] unknown $33 = Destructure { c: unknown c$34, d: unknown d$35, e: unknown $36, f: unknown $37, g: unknown $38, ...unknown i$39 } = unknown $32
33 - [2] unknown $40 = Destructure { e: unknown e$41 } = unknown $36
34 - [3] unknown $42 = Destructure { _f: unknown f$43 } = unknown $37
35 - [4] unknown $44 = Destructure { g: unknown $45 } = unknown $38
36 - [5] unknown $46 = Destructure { g: unknown $47 } = unknown $45
37 - [6] unknown $48 = Destructure { g: unknown g$49, ...unknown h$50 } = unknown $47
38 - [7] unknown $51 = LoadLocal unknown c$3
39 - [8] unknown $52 = LoadLocal unknown d$4
40 - [9] unknown $53 = LoadLocal unknown e$10
41 - [10] unknown $54 = LoadLocal unknown f$12
42 - [11] unknown $55 = LoadLocal unknown g$18
43 - [12] unknown $56 = LoadLocal unknown h$19
44 - [13] unknown $57 = LoadLocal unknown i$8
31 + [0] unknown $32 = LoadLocal unknown a$30
32 + [1] unknown $39 = Destructure { c: unknown c$33, d: unknown d$34, e: unknown $35, f: unknown $36, g: unknown $37, ...unknown i$38 } = unknown $32
33 + [2] unknown $41 = Destructure { e: unknown e$40 } = unknown $35
34 + [3] unknown $43 = Destructure { _f: unknown f$42 } = unknown $36
35 + [4] unknown $45 = Destructure { g: unknown $44 } = unknown $37
36 + [5] unknown $47 = Destructure { g: unknown $46 } = unknown $44
37 + [6] unknown $50 = Destructure { g: unknown g$48, ...unknown h$49 } = unknown $46
38 + [7] unknown $51 = LoadLocal unknown c$33
39 + [8] unknown $52 = LoadLocal unknown d$34
40 + [9] unknown $53 = LoadLocal unknown e$40
41 + [10] unknown $54 = LoadLocal unknown f$42
42 + [11] unknown $55 = LoadLocal unknown g$48
43 + [12] unknown $56 = LoadLocal unknown h$49
44 + [13] unknown $57 = LoadLocal unknown i$38
45 [14] unknown $58 = Array [unknown $51, unknown $52, unknown $53, unknown $54, unknown $55, unknown $56, unknown $57]
46 - [15] Return unknown $28
46 + [15] Return unknown $58
compiler/forget/crates/forget_fixtures/tests/snapshots/fixtures_test__fixtures@for-statement.js.snap
+18 -16
@@ -19,34 +19,36 @@ function foo(
19 entry bb0
20 bb0 (block)
21 [0] unknown $19 = 0
22 - [1] unknown $20 = StoreLocal Let unknown x$21 = unknown $19
22 + [1] unknown $21 = StoreLocal Let unknown x$20 = unknown $19
23 [2] For init=bb3 test=bb1 update=bb4 body=bb5 fallthrough=bb2
24 bb3 (loop)
25 predecessors: bb0
26 [3] unknown $22 = 0
27 - [4] unknown $23 = StoreLocal Let unknown i$24 = unknown $22
27 + [4] unknown $24 = StoreLocal Let unknown i$23 = unknown $22
28 [5] Goto bb1
29 bb1 (loop)
30 predecessors: bb3, bb4
31 - [6] unknown $25 = LoadLocal unknown i$4
32 - [7] unknown $26 = 10
33 - [8] unknown $27 = Binary unknown $25 < unknown $26
34 - [9] Branch unknown $16 consequent=bb5 alternate=bb2
31 + i$25: phi(bb3: i$23, bb4: i$38)
32 + x$29: phi(bb3: x$20, bb4: x$33)
33 + [6] unknown $26 = LoadLocal unknown i$25
34 + [7] unknown $27 = 10
35 + [8] unknown $28 = Binary unknown $26 < unknown $27
36 + [9] Branch unknown $28 consequent=bb5 alternate=bb2
37 bb5 (block)
38 predecessors: bb1
37 - [10] unknown $28 = LoadLocal unknown x$1
38 - [11] unknown $29 = LoadLocal unknown i$4
39 - [12] unknown $30 = Binary unknown $28 + unknown $29
40 - [13] unknown $31 = StoreLocal Reassign unknown x$32 = unknown $30
39 + [10] unknown $30 = LoadLocal unknown x$29
40 + [11] unknown $31 = LoadLocal unknown i$25
41 + [12] unknown $32 = Binary unknown $30 + unknown $31
42 + [13] unknown $34 = StoreLocal Reassign unknown x$33 = unknown $32
43 [14] Goto bb4
44 bb4 (loop)
45 predecessors: bb5
44 - [15] unknown $33 = LoadLocal unknown i$4
45 - [16] unknown $34 = 1
46 - [17] unknown $35 = Binary unknown $33 + unknown $34
47 - [18] unknown $36 = StoreLocal Reassign unknown i$37 = unknown $35
46 + [15] unknown $35 = LoadLocal unknown i$25
47 + [16] unknown $36 = 1
48 + [17] unknown $37 = Binary unknown $35 + unknown $36
49 + [18] unknown $39 = StoreLocal Reassign unknown i$38 = unknown $37
50 [19] Goto bb1
51 bb2 (block)
52 predecessors: bb1
51 - [20] unknown $38 = LoadLocal unknown x$1
52 - [21] Return unknown $17
53 + [20] unknown $40 = LoadLocal unknown x$29
54 + [21] Return unknown $40
compiler/forget/crates/forget_fixtures/tests/snapshots/fixtures_test__fixtures@function-expressions.js.snap
+36 -48
@@ -34,73 +34,61 @@ function Component(
34 entry bb0
35 bb0 (block)
36 [0] unknown $59 = 2
37 - [1] unknown $60 = StoreLocal Const unknown x$61 = unknown $59
38 - [2] unknown $62 = Function @deps[] @context[unknown x$61]:
37 + [1] unknown $61 = StoreLocal Const unknown x$60 = unknown $59
38 + [2] unknown $62 = Function @deps[] @context[unknown x$60]:
39 function foo(
40 unknown y$63,
41 )
42 entry bb1
43 bb1 (block)
44 [0] unknown $64 = 1
45 - [1] unknown $65 = StoreLocal Let unknown a$66 = unknown $64
46 - [2] unknown $67 = DeclareLocal Let unknown b$68
47 - [3] unknown $69 = LoadLocal unknown a$6
45 + [1] unknown $66 = StoreLocal Let unknown a$65 = unknown $64
46 + [2] unknown $68 = DeclareLocal Let unknown b$67
47 + [3] unknown $69 = 1
48 [4] unknown $70 = 1
49 - [5] unknown $71 = Binary unknown $69 === unknown $70
50 - [6] If unknown $18 consequent=bb3 alternate=bb4 fallthrough=bb2
51 - bb3 (block)
52 - predecessors: bb1
53 - [7] unknown $72 = 5
54 - [8] unknown $73 = 3
55 - [9] unknown $74 = 8
56 - [10] unknown $75 = StoreLocal Reassign unknown b$76 = unknown $74
57 - [11] Goto bb2
58 - bb4 (block)
59 - predecessors: bb1
60 - [12] unknown $77 = false
61 - [13] unknown $78 = StoreLocal Reassign unknown b$79 = unknown $77
62 - [14] Goto bb2
63 - bb2 (block)
64 - predecessors: bb3, bb4
65 - b$91: phi(bb3: b$76, bb4: b$79)
66 - [15] unknown $80 = LoadLocal unknown x$2
67 - [16] unknown $81 = LoadLocal unknown y$4
68 - [17] unknown $82 = Binary unknown $80 + unknown $81
69 - [18] unknown $83 = LoadLocal unknown a$6
70 - [19] unknown $84 = Binary unknown $82 + unknown $83
71 - [20] unknown $85 = LoadLocal unknown b$8
72 - [21] unknown $86 = Binary unknown $84 + unknown $85
73 - [22] unknown $87 = Function @deps[] @context[unknown x$61, unknown y$63, unknown a$66, unknown b$91]:
49 + [5] unknown $71 = true
50 + [6] unknown $72 = 5
51 + [7] unknown $73 = 3
52 + [8] unknown $74 = 8
53 + [9] unknown $76 = StoreLocal Reassign unknown b$75 = unknown $74
54 + [10] unknown $81 = 2
55 + [11] unknown $83 = LoadLocal unknown y$63
56 + [12] unknown $84 = Binary unknown $81 + unknown $83
57 + [13] unknown $86 = 1
58 + [14] unknown $87 = Binary unknown $84 + unknown $86
59 + [15] unknown $89 = 8
60 + [16] unknown $90 = Binary unknown $87 + unknown $89
61 + [17] unknown $91 = Function @deps[] @context[unknown x$60, unknown y$63, unknown a$65, unknown b$75]:
62 function bar(
63 unknown z$92,
64 )
65 entry bb5
66 bb5 (block)
67 [0] unknown $93 = 2
80 - [1] unknown $94 = StoreLocal Let unknown c$95 = unknown $93
81 - [2] unknown $96 = DeclareLocal Let unknown d$97
68 + [1] unknown $95 = StoreLocal Let unknown c$94 = unknown $93
69 + [2] unknown $97 = DeclareLocal Let unknown d$96
70 [3] unknown $98 = 3
83 - [4] unknown $99 = StoreLocal Reassign unknown d$100 = unknown $98
84 - [5] unknown $101 = LoadLocal unknown x$2
85 - [6] unknown $102 = LoadLocal unknown y$4
71 + [4] unknown $100 = StoreLocal Reassign unknown d$99 = unknown $98
72 + [5] unknown $101 = LoadLocal unknown x$80
73 + [6] unknown $102 = LoadLocal unknown y$82
74 [7] unknown $103 = Binary unknown $101 + unknown $102
87 - [8] unknown $104 = LoadLocal unknown a$6
75 + [8] unknown $104 = LoadLocal unknown a$85
76 [9] unknown $105 = Binary unknown $103 + unknown $104
89 - [10] unknown $106 = LoadLocal unknown b$8
77 + [10] unknown $106 = LoadLocal unknown b$88
78 [11] unknown $107 = Binary unknown $105 + unknown $106
91 - [12] unknown $108 = LoadLocal unknown z$26
79 + [12] unknown $108 = LoadLocal unknown z$92
80 [13] unknown $109 = Binary unknown $107 + unknown $108
93 - [14] unknown $110 = LoadLocal unknown c$28
81 + [14] unknown $110 = 2
82 [15] unknown $111 = Binary unknown $109 + unknown $110
95 - [16] unknown $112 = LoadLocal unknown d$30
83 + [16] unknown $112 = 3
84 [17] unknown $113 = Binary unknown $111 + unknown $112
85 [18] unknown $114 = <undefined>
98 - [19] Return unknown $47
99 - [23] unknown $115 = StoreLocal Const unknown bar$116 = unknown $87
100 - [24] unknown $117 = LoadLocal unknown bar$49
101 - [25] unknown $118 = LoadGlobal foo
102 - [26] unknown $119 = <undefined>
103 - [27] Return unknown $53
104 - [3] unknown $120 = StoreLocal Const unknown foo$121 = unknown $62
86 + [19] Return unknown $114
87 + [18] unknown $116 = StoreLocal Const unknown bar$115 = unknown $91
88 + [19] unknown $117 = LoadLocal unknown bar$115
89 + [20] unknown $118 = LoadGlobal foo
90 + [21] unknown $119 = <undefined>
91 + [22] Return unknown $119
92 + [3] unknown $121 = StoreLocal Const unknown foo$120 = unknown $62
93 [4] unknown $122 = <undefined>
106 - [5] Return unknown $57
94 + [5] Return unknown $122
compiler/forget/crates/forget_fixtures/tests/snapshots/fixtures_test__fixtures@identifiers.js.snap
+7 -7
@@ -31,11 +31,11 @@ bb0 (block)
31 [0] unknown $15 = LoadGlobal Math
32 [1] unknown $16 = LoadGlobal id
33 [2] unknown $17 = true
34 - [3] unknown $18 = StoreLocal Let unknown y$19 = unknown $17
34 + [3] unknown $19 = StoreLocal Let unknown y$18 = unknown $17
35 [4] unknown $20 = false
36 - [5] unknown $21 = StoreLocal Reassign unknown y$22 = unknown $20
37 - [6] unknown $23 = LoadLocal unknown y$4
38 - [7] unknown $24 = DeclareLocal Let unknown z$25
39 - [8] unknown $26 = LoadLocal unknown z$9
40 - [9] unknown $27 = LoadLocal unknown x$0
41 - [10] Return unknown $12
36 + [5] unknown $22 = StoreLocal Reassign unknown y$21 = unknown $20
37 + [6] unknown $23 = false
38 + [7] unknown $25 = DeclareLocal Let unknown z$24
39 + [8] unknown $26 = LoadLocal unknown z$24
40 + [9] unknown $27 = LoadLocal unknown x$14
41 + [10] Return unknown $27
compiler/forget/crates/forget_fixtures/tests/snapshots/fixtures_test__fixtures@if-statement.js.snap
+7 -7
@@ -23,18 +23,18 @@ function foo(
23 )
24 entry bb0
25 bb0 (block)
26 - [0] unknown $13 = LoadLocal unknown a$0
27 - [1] If unknown $6 consequent=bb2 alternate=bb4 fallthrough=bb1
26 + [0] unknown $13 = LoadLocal unknown a$9
27 + [1] If unknown $13 consequent=bb2 alternate=bb4 fallthrough=bb1
28 bb2 (block)
29 predecessors: bb0
30 - [2] unknown $14 = LoadLocal unknown b$1
31 - [3] Return unknown $4
30 + [2] unknown $14 = LoadLocal unknown b$10
31 + [3] Return unknown $14
32 bb4 (block)
33 predecessors: bb0
34 - [4] unknown $15 = LoadLocal unknown c$2
34 + [4] unknown $15 = LoadLocal unknown c$11
35 [5] Goto bb1
36 bb1 (block)
37 predecessors: bb4
38 - [6] unknown $16 = LoadLocal unknown d$3
38 + [6] unknown $16 = LoadLocal unknown d$12
39 [7] unknown $17 = <undefined>
40 - [8] Return unknown $8
40 + [8] Return unknown $17
compiler/forget/crates/forget_fixtures/tests/snapshots/fixtures_test__fixtures@simple-function.js.snap
+11 -11
@@ -23,24 +23,24 @@ entry bb0
23 bb0 (block)
24 [0] unknown $24 = LoadGlobal Math
25 [1] unknown $25 = 0
26 - [2] unknown $26 = StoreLocal Let unknown b$27 = unknown $25
27 - [3] unknown $28 = Function @deps[] @context[unknown a$23, unknown b$27]:
26 + [2] unknown $27 = StoreLocal Let unknown b$26 = unknown $25
27 + [3] unknown $28 = Function @deps[] @context[unknown a$23, unknown b$26]:
28 function foo_(
29 unknown c$29,
30 )
31 entry bb1
32 bb1 (block)
33 [0] unknown $30 = 1
34 - [1] unknown $31 = StoreLocal Let unknown d$32 = unknown $30
35 - [2] unknown $33 = LoadLocal unknown a$0
36 - [3] unknown $34 = LoadLocal unknown b$3
34 + [1] unknown $32 = StoreLocal Let unknown d$31 = unknown $30
35 + [2] unknown $33 = LoadLocal unknown a$23
36 + [3] unknown $34 = 0
37 [4] unknown $35 = Binary unknown $33 + unknown $34
38 - [5] unknown $36 = LoadLocal unknown c$5
38 + [5] unknown $36 = LoadLocal unknown c$29
39 [6] unknown $37 = Binary unknown $35 + unknown $36
40 - [7] unknown $38 = LoadLocal unknown d$7
40 + [7] unknown $38 = 1
41 [8] unknown $39 = Binary unknown $37 + unknown $38
42 - [9] Return unknown $15
43 - [4] unknown $40 = StoreLocal Const unknown foo$41 = unknown $28
44 - [5] unknown $42 = LoadLocal unknown foo$18
42 + [9] Return unknown $39
43 + [4] unknown $41 = StoreLocal Const unknown foo$40 = unknown $28
44 + [5] unknown $42 = LoadLocal unknown foo$40
45 [6] unknown $43 = Call unknown $42()
46 - [7] Return unknown $21
46 + [7] Return unknown $43
compiler/forget/crates/forget_fixtures/tests/snapshots/fixtures_test__fixtures@simple-ssa.js.snap new
+41
@@ -0,0 +1,41 @@
1 +---
2 +source: crates/forget_fixtures/tests/fixtures_test.rs
3 +expression: "format!(\"Input:\\n{input}\\n\\nOutput:\\n{output}\")"
4 +input_file: crates/forget_fixtures/tests/fixtures/simple-ssa.js
5 +---
6 +Input:
7 +function Component(props) {
8 + let a;
9 + if (props) {
10 + a = 1;
11 + } else {
12 + a = 2;
13 + }
14 + return a;
15 +}
16 +
17 +
18 +Output:
19 +function Component(
20 + unknown props$10,
21 +)
22 +entry bb0
23 +bb0 (block)
24 + [0] unknown $12 = DeclareLocal Let unknown a$11
25 + [1] unknown $13 = LoadLocal unknown props$10
26 + [2] If unknown $13 consequent=bb2 alternate=bb3 fallthrough=bb1
27 +bb2 (block)
28 + predecessors: bb0
29 + [3] unknown $14 = 1
30 + [4] unknown $16 = StoreLocal Reassign unknown a$15 = unknown $14
31 + [5] Goto bb1
32 +bb3 (block)
33 + predecessors: bb0
34 + [6] unknown $17 = 2
35 + [7] unknown $19 = StoreLocal Reassign unknown a$18 = unknown $17
36 + [8] Goto bb1
37 +bb1 (block)
38 + predecessors: bb2, bb3
39 + a$20: phi(bb2: a$15, bb3: a$18)
40 + [9] unknown $21 = LoadLocal unknown a$20
41 + [10] Return unknown $21
compiler/forget/crates/forget_fixtures/tests/snapshots/fixtures_test__fixtures@simple.js.snap
+1 -1
@@ -24,4 +24,4 @@ bb0 (block)
24 [6] unknown $16 = Array [unknown $15]
25 [7] unknown $17 = Array [unknown $10, unknown $11, unknown $12, unknown $13, unknown $14, ...unknown $16]
26 [8] unknown $18 = 2
27 - [9] Return unknown $8
27 + [9] Return unknown $18
compiler/forget/crates/forget_fixtures/tests/snapshots/fixtures_test__fixtures@ssa-reassign-if.js.snap
+20 -17
@@ -29,42 +29,45 @@ function Component(
29 )
30 entry bb0
31 bb0 (block)
32 - [0] unknown $28 = DeclareLocal Let unknown x$29
32 + [0] unknown $29 = DeclareLocal Let unknown x$28
33 [1] unknown $30 = 0
34 - [2] unknown $31 = StoreLocal Let unknown y$32 = unknown $30
34 + [2] unknown $32 = StoreLocal Let unknown y$31 = unknown $30
35 [3] unknown $33 = 10
36 - [4] unknown $34 = StoreLocal Let unknown z$35 = unknown $33
37 - [5] unknown $36 = LoadLocal unknown a$0
38 - [6] If unknown $19 consequent=bb2 alternate=bb6 fallthrough=bb1
36 + [4] unknown $35 = StoreLocal Let unknown z$34 = unknown $33
37 + [5] unknown $36 = LoadLocal unknown a$26
38 + [6] If unknown $36 consequent=bb2 alternate=bb6 fallthrough=bb1
39 bb2 (block)
40 predecessors: bb0
41 [7] unknown $37 = 1
42 - [8] unknown $38 = StoreLocal Reassign unknown x$39 = unknown $37
43 - [9] unknown $40 = LoadLocal unknown b$1
44 - [10] If unknown $16 consequent=bb4 alternate=bb5 fallthrough=bb3
42 + [8] unknown $39 = StoreLocal Reassign unknown x$38 = unknown $37
43 + [9] unknown $40 = LoadLocal unknown b$27
44 + [10] If unknown $40 consequent=bb4 alternate=bb5 fallthrough=bb3
45 bb4 (block)
46 predecessors: bb2
47 [11] unknown $41 = 20
48 - [12] unknown $42 = StoreLocal Reassign unknown z$43 = unknown $41
48 + [12] unknown $43 = StoreLocal Reassign unknown z$42 = unknown $41
49 [13] Goto bb3
50 bb5 (block)
51 predecessors: bb2
52 [14] unknown $44 = 30
53 - [15] unknown $45 = StoreLocal Reassign unknown z$46 = unknown $44
53 + [15] unknown $46 = StoreLocal Reassign unknown z$45 = unknown $44
54 [16] Goto bb3
55 bb3 (block)
56 predecessors: bb4, bb5
57 + z$58: phi(bb4: z$42, bb5: z$45)
58 [17] Goto bb1
59 bb6 (block)
60 predecessors: bb0
61 [18] unknown $47 = 2
61 - [19] unknown $48 = StoreLocal Reassign unknown x$49 = unknown $47
62 + [19] unknown $49 = StoreLocal Reassign unknown x$48 = unknown $47
63 [20] Goto bb1
64 bb1 (block)
65 predecessors: bb3, bb6
65 - [21] unknown $50 = LoadLocal unknown x$2
66 - [22] unknown $51 = LoadLocal unknown y$5
67 - [23] unknown $52 = Binary unknown $50 + unknown $51
68 - [24] unknown $53 = LoadLocal unknown z$8
69 - [25] unknown $54 = Binary unknown $52 + unknown $53
70 - [26] Return unknown $24
66 + x$50: phi(bb3: x$38, bb6: x$48)
67 + z$57: phi(bb3: z$58, bb6: z$34)
68 + [21] unknown $52 = LoadLocal unknown x$50
69 + [22] unknown $55 = 0
70 + [23] unknown $56 = Binary unknown $52 + unknown $55
71 + [24] unknown $59 = LoadLocal unknown z$57
72 + [25] unknown $60 = Binary unknown $56 + unknown $59
73 + [26] Return unknown $60
compiler/forget/crates/forget_fixtures/tests/snapshots/fixtures_test__fixtures@use-memo.js.snap
+4 -4
@@ -24,11 +24,11 @@ bb0 (block)
24 bb1 (block)
25 predecessors: bb0
26 [3] unknown $13 = LoadGlobal y
27 - [4] unknown $19 = StoreLocal Reassign unknown t$18 = unknown $2
27 + [4] unknown $19 = StoreLocal Reassign unknown t$18 = unknown $13
28 [5] Goto bb6
29 bb6 (block)
30 predecessors: bb1
31 [6] unknown $14 = LoadLocal unknown t$18
32 - [7] unknown $15 = StoreLocal Const unknown x$16 = unknown $14
33 - [8] unknown $17 = LoadLocal unknown x$6
34 - [9] Return unknown $8
32 + [7] unknown $16 = StoreLocal Const unknown x$15 = unknown $14
33 + [8] unknown $17 = LoadLocal unknown x$15
34 + [9] Return unknown $17
compiler/forget/crates/forget_hir/src/instruction.rs
+4 -18
@@ -73,26 +73,10 @@ impl Instruction {
73 Ok(())
74 }
75
76 - pub fn each_identifier_load<F>(&mut self, mut f: F) -> ()
76 + pub fn each_identifier_load<F>(&mut self, f: F) -> ()
77 where
78 F: FnMut(&mut IdentifierOperand) -> (),
79 {
80 - // match &mut self.value {
81 - // InstructionValue::LoadLocal(instr) => f(&mut instr.place),
82 - // InstructionValue::Array(_)
83 - // | InstructionValue::Binary(_)
84 - // | InstructionValue::Call(_)
85 - // | InstructionValue::DeclareContext(_)
86 - // | InstructionValue::DeclareLocal(_)
87 - // | InstructionValue::Destructure(_)
88 - // | InstructionValue::LoadContext(_)
89 - // | InstructionValue::LoadGlobal(_)
90 - // | InstructionValue::Primitive(_)
91 - // | InstructionValue::StoreLocal(_)
92 - // | InstructionValue::Function(_)
93 - // | InstructionValue::JSXElement(_)
94 - // | InstructionValue::Tombstone => {}
95 - // }
80 self.each_operand(f);
81 }
82
@@ -148,11 +132,13 @@ impl Instruction {
132 InstructionValue::Destructure(value) => {
133 f(&mut value.value);
134 }
135 + InstructionValue::LoadLocal(value) => {
136 + f(&mut value.place);
137 + }
138 InstructionValue::DeclareContext(_)
139 | InstructionValue::LoadContext(_)
140 | InstructionValue::LoadGlobal(_)
141 | InstructionValue::DeclareLocal(_)
155 - | InstructionValue::LoadLocal(_)
142 | InstructionValue::Primitive(_)
143 | InstructionValue::Tombstone => {}
144 }
compiler/forget/crates/forget_ssa/src/enter.rs
+57 -48
@@ -1,10 +1,12 @@
1 use std::cell::RefCell;
2 +use std::process::id;
3 use std::rc::Rc;
4
5 use forget_diagnostics::{invariant, Diagnostic};
6 use forget_hir::{
6 - BasicBlock, BlockId, Blocks, Environment, Function, Identifier, IdentifierData, IdentifierId,
7 - IdentifierOperand, Instruction, InstructionValue, LValue, MutableRange, Phi,
7 + BasicBlock, BlockId, BlockRewriter, BlockRewriterAction, Blocks, Environment, Function,
8 + Identifier, IdentifierData, IdentifierId, IdentifierOperand, InstructionValue, MutableRange,
9 + Phi, HIR,
10 };
11 use indexmap::{IndexMap, IndexSet};
12
@@ -18,16 +20,14 @@ pub fn enter_ssa_impl(
20 fun: &mut Function,
21 context_defs: Option<IndexMap<IdentifierId, Identifier>>,
22 ) -> Result<(), Diagnostic> {
21 - let blocks = &fun.body.blocks;
22 - let instructions = &mut fun.body.instructions;
23 - let mut builder = Builder::new(env, fun.body.entry, blocks);
23 + let mut builder = Builder::new(env, fun.body.entry, &fun.body.blocks);
24 if let Some(context_defs) = context_defs {
25 builder.initialize_context(context_defs);
26 }
27 for param in &mut fun.params {
28 builder.visit_param(param);
29 }
30 - visit_instructions(env, &mut builder, instructions)?;
30 + visit_instructions(env, &mut builder, &mut fun.body)?;
31
32 let mut states = builder.complete();
33
@@ -39,17 +39,22 @@ pub fn enter_ssa_impl(
39 Ok(())
40 }
41
42 -fn visit_instructions<'e, 'f>(
42 +fn visit_instructions<'e>(
43 env: &Environment,
44 - builder: &mut Builder<'e, 'f>,
45 - instructions: &mut Vec<Instruction>,
44 + builder: &mut Builder<'e>,
45 + hir: &mut HIR,
46 ) -> Result<(), Diagnostic> {
47 - builder.each_block(|block, builder| {
47 + let instructions = &mut hir.instructions;
48 + let blocks = &mut hir.blocks;
49 + let mut rewriter = BlockRewriter::new(blocks, hir.entry);
50 +
51 + rewriter.try_each_block(|mut block, _rewriter| {
52 + builder.start_block(&block);
53 for instr_ix in &block.instructions {
54 let instr = &mut instructions[usize::from(*instr_ix)];
50 - builder.visit_store(&mut instr.lvalue)?;
51 - instr.try_each_identifier_store(|store| builder.visit_store(store))?;
55 instr.each_identifier_load(|load| builder.visit_load(load));
56 + instr.try_each_identifier_store(|store| builder.visit_store(store))?;
57 + builder.visit_store(&mut instr.lvalue)?;
58
59 if let InstructionValue::Function(fun) = &mut instr.value {
60 // Lookup each of the context variables referenced in the function
@@ -70,20 +75,26 @@ fn visit_instructions<'e, 'f>(
75 enter_ssa_impl(env, &mut fun.lowered_function, Some(context_defs))?;
76 }
77 }
73 - Ok(())
78 + block
79 + .terminal
80 + .value
81 + .each_operand(|load| builder.visit_load(load));
82 + builder.close_block(&block);
83 + Ok(BlockRewriterAction::Keep(block))
84 })
85 }
86
87 #[derive(Debug)]
78 -struct Builder<'e, 'f> {
88 +struct Builder<'e> {
89 env: &'e Environment,
80 - blocks: &'f Blocks,
90 + predecessors: IndexMap<BlockId, IndexSet<BlockId>>,
91
92 states: IndexMap<BlockId, BlockState>,
93 current: BlockId,
94 unsealed_predecessors: IndexMap<BlockId, usize>,
95 unknown: IndexSet<IdentifierId>,
96 context: IndexSet<IdentifierId>,
97 + visited: IndexSet<BlockId>,
98 }
99
100 #[derive(Debug)]
@@ -109,21 +120,26 @@ struct IncompletePhi {
120 new_id: Identifier,
121 }
122
112 -impl<'e, 'f> Builder<'e, 'f> {
113 - fn new(env: &'e Environment, entry: BlockId, blocks: &'f Blocks) -> Self {
123 +impl<'e> Builder<'e> {
124 + fn new(env: &'e Environment, entry: BlockId, blocks: &Blocks) -> Self {
125 let states = blocks
126 .block_ids()
127 .into_iter()
128 .map(|block_id| (block_id, BlockState::new()))
129 .collect();
130 + let predecessors = blocks
131 + .iter()
132 + .map(|block| (block.id, block.predecessors.clone()))
133 + .collect();
134 Self {
135 env,
121 - blocks,
136 + predecessors,
137 states,
138 current: entry,
139 unsealed_predecessors: Default::default(),
140 unknown: Default::default(),
141 context: Default::default(),
142 + visited: Default::default(),
143 }
144 }
145
@@ -183,8 +199,8 @@ impl<'e, 'f> Builder<'e, 'f> {
199 return identifier.clone();
200 }
201 // Else we have to look at predecessor blocks: bail if no predecessors
186 - let block = self.blocks.block(block_id);
187 - if block.predecessors.is_empty() {
202 + let predecessors = self.predecessors.get(&block_id).unwrap();
203 + if predecessors.is_empty() {
204 panic!("Unable to find previous id for {old_identifier:?}");
205 // self.unknown.insert(old_identifier.id);
206 // return old_identifier.clone();
@@ -202,8 +218,8 @@ impl<'e, 'f> Builder<'e, 'f> {
218 return new_identifier;
219 }
220 // If exactly one predecessor, check to see if we have a definition there
205 - if block.predecessors.len() == 1 {
206 - let predecessor = block.predecessors.iter().next().unwrap();
221 + if predecessors.len() == 1 {
222 + let predecessor = predecessors.first().unwrap();
223 let new_identifier = self.get_id_at(*predecessor, old_identifier);
224 let state = self.states.get_mut(&block_id).unwrap();
225 state.defs.insert(old_identifier.id, new_identifier.clone());
@@ -226,9 +242,9 @@ impl<'e, 'f> Builder<'e, 'f> {
242 identifier: new_identifier.clone(),
243 operands: Default::default(),
244 };
229 - let block = self.blocks.block(block_id);
230 - let preds = block.predecessors.clone();
231 - for pred_block_id in preds {
245 + // TODO: avoid clone here
246 + let predecessors = self.predecessors.get(&block_id).unwrap().clone();
247 + for pred_block_id in predecessors {
248 let pred_id = self.get_id_at(pred_block_id, old_identifier);
249 phi.operands.insert(pred_block_id, pred_id);
250 }
@@ -258,30 +274,23 @@ impl<'e, 'f> Builder<'e, 'f> {
274 }
275 }
276
261 - fn each_block<F>(&mut self, mut f: F) -> Result<(), Diagnostic>
262 - where
263 - F: FnMut(&BasicBlock, &mut Self) -> Result<(), Diagnostic>,
264 - {
265 - let mut visited = IndexSet::new();
266 - let block_ids = self.blocks.block_ids();
267 - for block_id in block_ids {
268 - visited.insert(block_id);
269 - self.current = block_id;
270 - let block = self.blocks.block(block_id);
271 - f(block, self)?;
272 - let successors = block.terminal.value.successors();
273 - for successor in successors {
274 - let block = self.blocks.block(successor);
275 - let count = self
276 - .unsealed_predecessors
277 - .entry(successor)
278 - .or_insert(block.predecessors.len());
279 - *count -= 1;
280 - if *count == 0 && visited.contains(&successor) {
281 - self.fix_incomplete_phis(successor)
282 - }
277 + fn start_block(&mut self, block: &BasicBlock) {
278 + self.current = block.id;
279 + self.visited.insert(block.id);
280 + }
281 +
282 + fn close_block(&mut self, block: &BasicBlock) {
283 + let successors = block.terminal.value.successors();
284 + for successor in successors {
285 + let preds = &self.predecessors.get(&successor).unwrap();
286 + let count = self
287 + .unsealed_predecessors
288 + .entry(successor)
289 + .or_insert(preds.len());
290 + *count -= 1;
291 + if *count == 0 && self.visited.contains(&successor) {
292 + self.fix_incomplete_phis(successor)
293 }
294 }
285 - Ok(())
295 }
296 }