+10

compiler-core/src/erlang.rs

View file Reviewed

··· 1191 1191 // exception in case the pattern doesn't match. 1192 1192 let case = builder.start_case(); 1193 1193 self.maybe_block_expr(builder, value); 1194 1194 + let case = builder.end_case_subject(case); 1194 1195 1195 1196 // This is the first branch for when the asserted pattern matches: it's 1196 1197 // going to run all the remaining statements in its body. ··· 1431 1432 builder.binary_operator(erlang_operator); 1432 1433 self.runtime_value(builder, &left); 1433 1434 self.runtime_value(builder, &right); 1435 1435 + let case = builder.end_case_subject(case); 1434 1436 1435 1437 // If the operator evaluates to true the assertion succeeded. 1436 1438 // We can just return nil. ··· 1481 1483 1482 1484 let case = builder.start_case(); 1483 1485 self.call_in_assert(builder, fun, &call_arguments); 1486 1486 + let case = builder.end_case_subject(case); 1484 1487 1485 1488 // If the operator evaluates to true the assertion succeeded. 1486 1489 // We can just return nil. ··· 1532 1535 | TypedExpr::Invalid { .. } => { 1533 1536 let case = builder.start_case(); 1534 1537 self.maybe_block_expr(builder, value); 1538 1538 + let case = builder.end_case_subject(case); 1535 1539 1536 1540 // If the expression evaluates to true the assertion succeeded. 1537 1541 // We can just return nil. ··· 1596 1600 ) { 1597 1601 let case = builder.start_case(); 1598 1602 self.maybe_block_expr(builder, left); 1603 1603 + let case = builder.end_case_subject(case); 1599 1604 1600 1605 // In case the first expression is true, we get to evaluate the second 1601 1606 // one as well, then we will be able to tell if the assertion failed or ··· 1608 1613 // Now we have to match on the right hand side! 1609 1614 let case = builder.start_case(); 1610 1615 self.maybe_block_expr(builder, right); 1616 1616 + let case = builder.end_case_subject(case); 1611 1617 1612 1618 // If it's true the assertion succeded! We can return `nil`. 1613 1619 let clause = builder.start_case_clause(); ··· 1676 1682 builder.binary_operator("orelse"); 1677 1683 self.maybe_block_expr(builder, left); 1678 1684 self.maybe_block_expr(builder, right); 1685 1685 + let case = builder.end_case_subject(case); 1679 1686 1680 1687 // If the result is true, then the assertion succeeded, we can return 1681 1688 // nil. ··· 2119 2126 builder.end_tuple(tuple); 2120 2127 } 2121 2128 } 2129 2129 + let case = builder.end_case_subject(case); 2122 2130 2123 2131 for clause in clauses { 2124 2132 let taken_names_before_clause = self.taken_names.clone(); ··· 2548 2556 2549 2557 let case = builder.start_case(); 2550 2558 self.maybe_block_expr(builder, right); 2559 2559 + let case = builder.end_case_subject(case); 2551 2560 2552 2561 // +0.0 -> +0.0 2553 2562 let clause = builder.start_case_clause(); ··· 2637 2646 2638 2647 let case = builder.start_case(); 2639 2648 self.maybe_block_expr(builder, right); 2649 2649 + let case = builder.end_case_subject(case); 2640 2650 2641 2651 // 0 -> 0 2642 2652 let clause = builder.start_case_clause();

+1

compiler-core/src/erlang/pattern.rs

View file Reviewed

··· 406 406 } else { 407 407 let case = builder.start_case(); 408 408 self.bit_array_size(builder, right); 409 409 + let case = builder.end_case_subject(case); 409 410 410 411 let clause = builder.start_case_clause(); 411 412 builder.int_pattern(BigInt::ZERO);

+25 -1

erlang-generation/src/lib.rs

View file Reviewed

··· 98 98 /// Represents an open case expression that has yet to be closed. 99 99 type Case; 100 100 101 101 + /// Represents an open case subject that has yet to be closed. 102 102 + type CaseSubject; 103 103 + 101 104 /// Represents an open case clause pattern that has yet to be generated. 102 105 type ClausePattern; 103 106 ··· 867 870 /// This starts a new case expression. 868 871 /// After this function is called you're supposed to first generate a single 869 872 /// expression; that's going to be the case subject being matched on. 873 873 + /// After that you must call `end_case_subject`. 870 874 /// 871 875 /// After that you're supposed to generate the case branches using the 872 876 /// `start_case_clause` function. ··· 876 880 /// ```ignore 877 881 /// let case = builder.start_case(); 878 882 /// builder.variable("wibble"); 883 883 + /// let case = builder.end_case_subject(); 879 884 /// 880 885 /// let clause = builder.start_case_clause(); 881 886 /// builder.discard_pattern(); ··· 895 900 /// end. 896 901 /// ``` 897 902 /// 898 898 - fn start_case(&mut self) -> Self::Case; 903 903 + fn start_case(&mut self) -> Self::CaseSubject; 904 904 + 905 905 + /// This ends the open case subject, after this you can start generating the 906 906 + /// case clauses. 907 907 + fn end_case_subject(&mut self, case: Self::CaseSubject) -> Self::Case; 899 908 900 909 /// This ends an open case expression. 901 910 /// Any code generated after this is not going to be part of it. ··· 1693 1702 type Block = (); 1694 1703 type Call = (); 1695 1704 type Case = (); 1705 1705 + type CaseSubject = (); 1696 1706 type ClauseBody = (); 1697 1707 type ClauseGuards = (); 1698 1708 type ClausePattern = (); ··· 2231 2241 self.position.push(ErlangSourceBuilderPosition::Case { 2232 2242 expected: ExpectedCaseItem::Subject, 2233 2243 }); 2244 2244 + } 2245 2245 + 2246 2246 + fn end_case_subject(&mut self, _case: Self::CaseSubject) -> Self::Case { 2247 2247 + // We need to make sure that just a single expression was generated as 2248 2248 + // the subject and then this function was called. 2249 2249 + // So we can assert that we're no longer expecting the subject but the 2250 2250 + // clauses and none has been generated yet. 2251 2251 + self.pop_leftover_items(); 2252 2252 + let Some(ErlangSourceBuilderPosition::Case { 2253 2253 + expected: ExpectedCaseItem::Branches { first: true }, 2254 2254 + }) = self.position.last() 2255 2255 + else { 2256 2256 + invalid_code_for_position!(self, "end case subject") 2257 2257 + }; 2234 2258 } 2235 2259 2236 2260 fn end_case(&mut self, _case: Self::Case) {