diff --git a/CHANGELOG.md b/CHANGELOG.md index 49ab429f1e..60b4fe053a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,10 @@ # 11.0.0-alpha.5 (Unreleased) +#### :boom: Breaking Change + +- Parse `assert` as a regular function. `assert` is no longer a unary expression. Example: before `assert 1 == 2` is parsed as `(assert 1) == 2`, now it is parsed as `assert(1 == 2)`. https://github.com/rescript-lang/rescript-compiler/pull/6180 + # 11.0.0-alpha.4 #### :rocket: Main New Feature diff --git a/jscomp/test/adt_optimize_test.res b/jscomp/test/adt_optimize_test.res index 2ab6e6edf2..1d693e8503 100644 Binary files a/jscomp/test/adt_optimize_test.res and b/jscomp/test/adt_optimize_test.res differ diff --git a/jscomp/test/bb.res b/jscomp/test/bb.res index daded17f8a..5933818126 100644 --- a/jscomp/test/bb.res +++ b/jscomp/test/bb.res @@ -10,7 +10,7 @@ let ff = x => | "a" => #a | "b" => #b | "c" => #c - | _ => assert false + | _ => assert(false) } let test = x => @@ -18,7 +18,7 @@ let test = x => | "a" => #a | "b" => #b | "c" => #c - | _ => assert false + | _ => assert(false) } { | #a => "a" | #b => "b" diff --git a/jscomp/test/bdd.res b/jscomp/test/bdd.res index 9d5d3afc26..109d61da03 100644 --- a/jscomp/test/bdd.res +++ b/jscomp/test/bdd.res @@ -57,7 +57,7 @@ let resize = newSize => { newArr[ind] = list{n, ...newArr[ind]} copyBucket(ns) - | _ => assert false + | _ => assert(false) } } @@ -118,7 +118,7 @@ let mkNode = (low, v, high) => { } else { lookup(ns) } - | _ => assert false + | _ => assert(false) } } @@ -298,7 +298,7 @@ let main = () => { for i in 1 to ntests { succeeded := succeeded.contents && test_hwb(bdd, random_vars(n)) } - assert succeeded.contents + assert(succeeded.contents) } let _ = main() diff --git a/jscomp/test/big_polyvar_test.res b/jscomp/test/big_polyvar_test.res index f8f30af5cd..8706dc37dc 100644 --- a/jscomp/test/big_polyvar_test.res +++ b/jscomp/test/big_polyvar_test.res @@ -311,604 +311,604 @@ let eq = (x: option, y: option) => | None => y == None } -assert (tToJs(#variant0) == "variant0") -assert (tToJs(#variant1) == "variant1") -assert (tToJs(#variant2) == "variant2") -assert (tToJs(#variant3) == "variant3") -assert (tToJs(#variant4) == "variant4") -assert (tToJs(#variant5) == "variant5") -assert (tToJs(#variant6) == "variant6") -assert (tToJs(#variant7) == "variant7") -assert (tToJs(#variant8) == "variant8") -assert (tToJs(#variant9) == "variant9") -assert (tToJs(#variant10) == "variant10") -assert (tToJs(#variant11) == "variant11") -assert (tToJs(#variant12) == "variant12") -assert (tToJs(#variant13) == "variant13") -assert (tToJs(#variant14) == "variant14") -assert (tToJs(#variant15) == "variant15") -assert (tToJs(#variant16) == "variant16") -assert (tToJs(#variant17) == "variant17") -assert (tToJs(#variant18) == "variant18") -assert (tToJs(#variant19) == "variant19") -assert (tToJs(#variant20) == "variant20") -assert (tToJs(#variant21) == "variant21") -assert (tToJs(#variant22) == "variant22") -assert (tToJs(#variant23) == "variant23") -assert (tToJs(#variant24) == "variant24") -assert (tToJs(#variant25) == "variant25") -assert (tToJs(#variant26) == "variant26") -assert (tToJs(#variant27) == "variant27") -assert (tToJs(#variant28) == "variant28") -assert (tToJs(#variant29) == "variant29") -assert (tToJs(#variant30) == "variant30") -assert (tToJs(#variant31) == "variant31") -assert (tToJs(#variant32) == "variant32") -assert (tToJs(#variant33) == "variant33") -assert (tToJs(#variant34) == "variant34") -assert (tToJs(#variant35) == "variant35") -assert (tToJs(#variant36) == "variant36") -assert (tToJs(#variant37) == "variant37") -assert (tToJs(#variant38) == "variant38") -assert (tToJs(#variant39) == "variant39") -assert (tToJs(#variant40) == "variant40") -assert (tToJs(#variant41) == "variant41") -assert (tToJs(#variant42) == "variant42") -assert (tToJs(#variant43) == "variant43") -assert (tToJs(#variant44) == "variant44") -assert (tToJs(#variant45) == "variant45") -assert (tToJs(#variant46) == "variant46") -assert (tToJs(#variant47) == "variant47") -assert (tToJs(#variant48) == "variant48") -assert (tToJs(#variant49) == "variant49") -assert (tToJs(#variant50) == "variant50") -assert (tToJs(#variant51) == "variant51") -assert (tToJs(#variant52) == "variant52") -assert (tToJs(#variant53) == "variant53") -assert (tToJs(#variant54) == "variant54") -assert (tToJs(#variant55) == "variant55") -assert (tToJs(#variant56) == "variant56") -assert (tToJs(#variant57) == "variant57") -assert (tToJs(#variant58) == "variant58") -assert (tToJs(#variant59) == "variant59") -assert (tToJs(#variant60) == "variant60") -assert (tToJs(#variant61) == "variant61") -assert (tToJs(#variant62) == "variant62") -assert (tToJs(#variant63) == "variant63") -assert (tToJs(#variant64) == "variant64") -assert (tToJs(#variant65) == "variant65") -assert (tToJs(#variant66) == "variant66") -assert (tToJs(#variant67) == "variant67") -assert (tToJs(#variant68) == "variant68") -assert (tToJs(#variant69) == "variant69") -assert (tToJs(#variant70) == "variant70") -assert (tToJs(#variant71) == "variant71") -assert (tToJs(#variant72) == "variant72") -assert (tToJs(#variant73) == "variant73") -assert (tToJs(#variant74) == "variant74") -assert (tToJs(#variant75) == "variant75") -assert (tToJs(#variant76) == "variant76") -assert (tToJs(#variant77) == "variant77") -assert (tToJs(#variant78) == "variant78") -assert (tToJs(#variant79) == "variant79") -assert (tToJs(#variant80) == "variant80") -assert (tToJs(#variant81) == "variant81") -assert (tToJs(#variant82) == "variant82") -assert (tToJs(#variant83) == "variant83") -assert (tToJs(#variant84) == "variant84") -assert (tToJs(#variant85) == "variant85") -assert (tToJs(#variant86) == "variant86") -assert (tToJs(#variant87) == "variant87") -assert (tToJs(#variant88) == "variant88") -assert (tToJs(#variant89) == "variant89") -assert (tToJs(#variant90) == "variant90") -assert (tToJs(#variant91) == "variant91") -assert (tToJs(#variant92) == "variant92") -assert (tToJs(#variant93) == "variant93") -assert (tToJs(#variant94) == "variant94") -assert (tToJs(#variant95) == "variant95") -assert (tToJs(#variant96) == "variant96") -assert (tToJs(#variant97) == "variant97") -assert (tToJs(#variant98) == "variant98") -assert (tToJs(#variant99) == "variant99") -assert (tToJs(#variant100) == "variant100") -assert (tToJs(#variant101) == "variant101") -assert (tToJs(#variant102) == "variant102") -assert (tToJs(#variant103) == "variant103") -assert (tToJs(#variant104) == "variant104") -assert (tToJs(#variant105) == "variant105") -assert (tToJs(#variant106) == "variant106") -assert (tToJs(#variant107) == "variant107") -assert (tToJs(#variant108) == "variant108") -assert (tToJs(#variant109) == "variant109") -assert (tToJs(#variant110) == "variant110") -assert (tToJs(#variant111) == "variant111") -assert (tToJs(#variant112) == "variant112") -assert (tToJs(#variant113) == "variant113") -assert (tToJs(#variant114) == "variant114") -assert (tToJs(#variant115) == "variant115") -assert (tToJs(#variant116) == "variant116") -assert (tToJs(#variant117) == "variant117") -assert (tToJs(#variant118) == "variant118") -assert (tToJs(#variant119) == "variant119") -assert (tToJs(#variant120) == "variant120") -assert (tToJs(#variant121) == "variant121") -assert (tToJs(#variant122) == "variant122") -assert (tToJs(#variant123) == "variant123") -assert (tToJs(#variant124) == "variant124") -assert (tToJs(#variant125) == "variant125") -assert (tToJs(#variant126) == "variant126") -assert (tToJs(#variant127) == "variant127") -assert (tToJs(#variant128) == "variant128") -assert (tToJs(#variant129) == "variant129") -assert (tToJs(#variant130) == "variant130") -assert (tToJs(#variant131) == "variant131") -assert (tToJs(#variant132) == "variant132") -assert (tToJs(#variant133) == "variant133") -assert (tToJs(#variant134) == "variant134") -assert (tToJs(#variant135) == "variant135") -assert (tToJs(#variant136) == "variant136") -assert (tToJs(#variant137) == "variant137") -assert (tToJs(#variant138) == "variant138") -assert (tToJs(#variant139) == "variant139") -assert (tToJs(#variant140) == "variant140") -assert (tToJs(#variant141) == "variant141") -assert (tToJs(#variant142) == "variant142") -assert (tToJs(#variant143) == "variant143") -assert (tToJs(#variant144) == "variant144") -assert (tToJs(#variant145) == "variant145") -assert (tToJs(#variant146) == "variant146") -assert (tToJs(#variant147) == "variant147") -assert (tToJs(#variant148) == "variant148") -assert (tToJs(#variant149) == "variant149") -assert (tToJs(#variant150) == "variant150") -assert (tToJs(#variant151) == "variant151") -assert (tToJs(#variant152) == "variant152") -assert (tToJs(#variant153) == "variant153") -assert (tToJs(#variant154) == "variant154") -assert (tToJs(#variant155) == "variant155") -assert (tToJs(#variant156) == "variant156") -assert (tToJs(#variant157) == "variant157") -assert (tToJs(#variant158) == "variant158") -assert (tToJs(#variant159) == "variant159") -assert (tToJs(#variant160) == "variant160") -assert (tToJs(#variant161) == "variant161") -assert (tToJs(#variant162) == "variant162") -assert (tToJs(#variant163) == "variant163") -assert (tToJs(#variant164) == "variant164") -assert (tToJs(#variant165) == "variant165") -assert (tToJs(#variant166) == "variant166") -assert (tToJs(#variant167) == "variant167") -assert (tToJs(#variant168) == "variant168") -assert (tToJs(#variant169) == "variant169") -assert (tToJs(#variant170) == "variant170") -assert (tToJs(#variant171) == "variant171") -assert (tToJs(#variant172) == "variant172") -assert (tToJs(#variant173) == "variant173") -assert (tToJs(#variant174) == "variant174") -assert (tToJs(#variant175) == "variant175") -assert (tToJs(#variant176) == "variant176") -assert (tToJs(#variant177) == "variant177") -assert (tToJs(#variant178) == "variant178") -assert (tToJs(#variant179) == "variant179") -assert (tToJs(#variant180) == "variant180") -assert (tToJs(#variant181) == "variant181") -assert (tToJs(#variant182) == "variant182") -assert (tToJs(#variant183) == "variant183") -assert (tToJs(#variant184) == "variant184") -assert (tToJs(#variant185) == "variant185") -assert (tToJs(#variant186) == "variant186") -assert (tToJs(#variant187) == "variant187") -assert (tToJs(#variant188) == "variant188") -assert (tToJs(#variant189) == "variant189") -assert (tToJs(#variant190) == "variant190") -assert (tToJs(#variant191) == "variant191") -assert (tToJs(#variant192) == "variant192") -assert (tToJs(#variant193) == "variant193") -assert (tToJs(#variant194) == "variant194") -assert (tToJs(#variant195) == "variant195") -assert (tToJs(#variant196) == "variant196") -assert (tToJs(#variant197) == "variant197") -assert (tToJs(#variant198) == "variant198") -assert (tToJs(#variant199) == "variant199") -assert (tToJs(#variant200) == "variant200") -assert (tToJs(#variant201) == "variant201") -assert (tToJs(#variant202) == "variant202") -assert (tToJs(#variant203) == "variant203") -assert (tToJs(#variant204) == "variant204") -assert (tToJs(#variant205) == "variant205") -assert (tToJs(#variant206) == "variant206") -assert (tToJs(#variant207) == "variant207") -assert (tToJs(#variant208) == "variant208") -assert (tToJs(#variant209) == "variant209") -assert (tToJs(#variant210) == "variant210") -assert (tToJs(#variant211) == "variant211") -assert (tToJs(#variant212) == "variant212") -assert (tToJs(#variant213) == "variant213") -assert (tToJs(#variant214) == "variant214") -assert (tToJs(#variant215) == "variant215") -assert (tToJs(#variant216) == "variant216") -assert (tToJs(#variant217) == "variant217") -assert (tToJs(#variant218) == "variant218") -assert (tToJs(#variant219) == "variant219") -assert (tToJs(#variant220) == "variant220") -assert (tToJs(#variant221) == "variant221") -assert (tToJs(#variant222) == "variant222") -assert (tToJs(#variant223) == "variant223") -assert (tToJs(#variant224) == "variant224") -assert (tToJs(#variant225) == "variant225") -assert (tToJs(#variant226) == "variant226") -assert (tToJs(#variant227) == "variant227") -assert (tToJs(#variant228) == "variant228") -assert (tToJs(#variant229) == "variant229") -assert (tToJs(#variant230) == "variant230") -assert (tToJs(#variant231) == "variant231") -assert (tToJs(#variant232) == "variant232") -assert (tToJs(#variant233) == "variant233") -assert (tToJs(#variant234) == "variant234") -assert (tToJs(#variant235) == "variant235") -assert (tToJs(#variant236) == "variant236") -assert (tToJs(#variant237) == "variant237") -assert (tToJs(#variant238) == "variant238") -assert (tToJs(#variant239) == "variant239") -assert (tToJs(#variant240) == "variant240") -assert (tToJs(#variant241) == "variant241") -assert (tToJs(#variant242) == "variant242") -assert (tToJs(#variant243) == "variant243") -assert (tToJs(#variant244) == "variant244") -assert (tToJs(#variant245) == "variant245") -assert (tToJs(#variant246) == "variant246") -assert (tToJs(#variant247) == "variant247") -assert (tToJs(#variant248) == "variant248") -assert (tToJs(#variant249) == "variant249") -assert (tToJs(#variant250) == "variant250") -assert (tToJs(#variant251) == "variant251") -assert (tToJs(#variant252) == "variant252") -assert (tToJs(#variant253) == "variant253") -assert (tToJs(#variant254) == "variant254") -assert (tToJs(#variant255) == "variant255") -assert (tToJs(#variant256) == "variant256") -assert (tToJs(#variant257) == "variant257") -assert (tToJs(#variant258) == "variant258") -assert (tToJs(#variant259) == "variant259") -assert (tToJs(#variant260) == "variant260") -assert (tToJs(#variant261) == "variant261") -assert (tToJs(#variant262) == "variant262") -assert (tToJs(#variant263) == "variant263") -assert (tToJs(#variant264) == "variant264") -assert (tToJs(#variant265) == "variant265") -assert (tToJs(#variant266) == "variant266") -assert (tToJs(#variant267) == "variant267") -assert (tToJs(#variant268) == "variant268") -assert (tToJs(#variant269) == "variant269") -assert (tToJs(#variant270) == "variant270") -assert (tToJs(#variant271) == "variant271") -assert (tToJs(#variant272) == "variant272") -assert (tToJs(#variant273) == "variant273") -assert (tToJs(#variant274) == "variant274") -assert (tToJs(#variant275) == "variant275") -assert (tToJs(#variant276) == "variant276") -assert (tToJs(#variant277) == "variant277") -assert (tToJs(#variant278) == "variant278") -assert (tToJs(#variant279) == "variant279") -assert (tToJs(#variant280) == "variant280") -assert (tToJs(#variant281) == "variant281") -assert (tToJs(#variant282) == "variant282") -assert (tToJs(#variant283) == "variant283") -assert (tToJs(#variant284) == "variant284") -assert (tToJs(#variant285) == "variant285") -assert (tToJs(#variant286) == "variant286") -assert (tToJs(#variant287) == "variant287") -assert (tToJs(#variant288) == "variant288") -assert (tToJs(#variant289) == "variant289") -assert (tToJs(#variant290) == "variant290") -assert (tToJs(#variant291) == "variant291") -assert (tToJs(#variant292) == "variant292") -assert (tToJs(#variant293) == "variant293") -assert (tToJs(#variant294) == "variant294") -assert (tToJs(#variant295) == "variant295") -assert (tToJs(#variant296) == "variant296") -assert (tToJs(#variant297) == "variant297") -assert (tToJs(#variant298) == "variant298") -assert (tToJs(#variant299) == "variant299") -assert eq(tFromJs("variant0"), Some(#variant0)) -assert eq(tFromJs("variant1"), Some(#variant1)) -assert eq(tFromJs("variant2"), Some(#variant2)) -assert eq(tFromJs("variant3"), Some(#variant3)) -assert eq(tFromJs("variant4"), Some(#variant4)) -assert eq(tFromJs("variant5"), Some(#variant5)) -assert eq(tFromJs("variant6"), Some(#variant6)) -assert eq(tFromJs("variant7"), Some(#variant7)) -assert eq(tFromJs("variant8"), Some(#variant8)) -assert eq(tFromJs("variant9"), Some(#variant9)) -assert eq(tFromJs("variant10"), Some(#variant10)) -assert eq(tFromJs("variant11"), Some(#variant11)) -assert eq(tFromJs("variant12"), Some(#variant12)) -assert eq(tFromJs("variant13"), Some(#variant13)) -assert eq(tFromJs("variant14"), Some(#variant14)) -assert eq(tFromJs("variant15"), Some(#variant15)) -assert eq(tFromJs("variant16"), Some(#variant16)) -assert eq(tFromJs("variant17"), Some(#variant17)) -assert eq(tFromJs("variant18"), Some(#variant18)) -assert eq(tFromJs("variant19"), Some(#variant19)) -assert eq(tFromJs("variant20"), Some(#variant20)) -assert eq(tFromJs("variant21"), Some(#variant21)) -assert eq(tFromJs("variant22"), Some(#variant22)) -assert eq(tFromJs("variant23"), Some(#variant23)) -assert eq(tFromJs("variant24"), Some(#variant24)) -assert eq(tFromJs("variant25"), Some(#variant25)) -assert eq(tFromJs("variant26"), Some(#variant26)) -assert eq(tFromJs("variant27"), Some(#variant27)) -assert eq(tFromJs("variant28"), Some(#variant28)) -assert eq(tFromJs("variant29"), Some(#variant29)) -assert eq(tFromJs("variant30"), Some(#variant30)) -assert eq(tFromJs("variant31"), Some(#variant31)) -assert eq(tFromJs("variant32"), Some(#variant32)) -assert eq(tFromJs("variant33"), Some(#variant33)) -assert eq(tFromJs("variant34"), Some(#variant34)) -assert eq(tFromJs("variant35"), Some(#variant35)) -assert eq(tFromJs("variant36"), Some(#variant36)) -assert eq(tFromJs("variant37"), Some(#variant37)) -assert eq(tFromJs("variant38"), Some(#variant38)) -assert eq(tFromJs("variant39"), Some(#variant39)) -assert eq(tFromJs("variant40"), Some(#variant40)) -assert eq(tFromJs("variant41"), Some(#variant41)) -assert eq(tFromJs("variant42"), Some(#variant42)) -assert eq(tFromJs("variant43"), Some(#variant43)) -assert eq(tFromJs("variant44"), Some(#variant44)) -assert eq(tFromJs("variant45"), Some(#variant45)) -assert eq(tFromJs("variant46"), Some(#variant46)) -assert eq(tFromJs("variant47"), Some(#variant47)) -assert eq(tFromJs("variant48"), Some(#variant48)) -assert eq(tFromJs("variant49"), Some(#variant49)) -assert eq(tFromJs("variant50"), Some(#variant50)) -assert eq(tFromJs("variant51"), Some(#variant51)) -assert eq(tFromJs("variant52"), Some(#variant52)) -assert eq(tFromJs("variant53"), Some(#variant53)) -assert eq(tFromJs("variant54"), Some(#variant54)) -assert eq(tFromJs("variant55"), Some(#variant55)) -assert eq(tFromJs("variant56"), Some(#variant56)) -assert eq(tFromJs("variant57"), Some(#variant57)) -assert eq(tFromJs("variant58"), Some(#variant58)) -assert eq(tFromJs("variant59"), Some(#variant59)) -assert eq(tFromJs("variant60"), Some(#variant60)) -assert eq(tFromJs("variant61"), Some(#variant61)) -assert eq(tFromJs("variant62"), Some(#variant62)) -assert eq(tFromJs("variant63"), Some(#variant63)) -assert eq(tFromJs("variant64"), Some(#variant64)) -assert eq(tFromJs("variant65"), Some(#variant65)) -assert eq(tFromJs("variant66"), Some(#variant66)) -assert eq(tFromJs("variant67"), Some(#variant67)) -assert eq(tFromJs("variant68"), Some(#variant68)) -assert eq(tFromJs("variant69"), Some(#variant69)) -assert eq(tFromJs("variant70"), Some(#variant70)) -assert eq(tFromJs("variant71"), Some(#variant71)) -assert eq(tFromJs("variant72"), Some(#variant72)) -assert eq(tFromJs("variant73"), Some(#variant73)) -assert eq(tFromJs("variant74"), Some(#variant74)) -assert eq(tFromJs("variant75"), Some(#variant75)) -assert eq(tFromJs("variant76"), Some(#variant76)) -assert eq(tFromJs("variant77"), Some(#variant77)) -assert eq(tFromJs("variant78"), Some(#variant78)) -assert eq(tFromJs("variant79"), Some(#variant79)) -assert eq(tFromJs("variant80"), Some(#variant80)) -assert eq(tFromJs("variant81"), Some(#variant81)) -assert eq(tFromJs("variant82"), Some(#variant82)) -assert eq(tFromJs("variant83"), Some(#variant83)) -assert eq(tFromJs("variant84"), Some(#variant84)) -assert eq(tFromJs("variant85"), Some(#variant85)) -assert eq(tFromJs("variant86"), Some(#variant86)) -assert eq(tFromJs("variant87"), Some(#variant87)) -assert eq(tFromJs("variant88"), Some(#variant88)) -assert eq(tFromJs("variant89"), Some(#variant89)) -assert eq(tFromJs("variant90"), Some(#variant90)) -assert eq(tFromJs("variant91"), Some(#variant91)) -assert eq(tFromJs("variant92"), Some(#variant92)) -assert eq(tFromJs("variant93"), Some(#variant93)) -assert eq(tFromJs("variant94"), Some(#variant94)) -assert eq(tFromJs("variant95"), Some(#variant95)) -assert eq(tFromJs("variant96"), Some(#variant96)) -assert eq(tFromJs("variant97"), Some(#variant97)) -assert eq(tFromJs("variant98"), Some(#variant98)) -assert eq(tFromJs("variant99"), Some(#variant99)) -assert eq(tFromJs("variant100"), Some(#variant100)) -assert eq(tFromJs("variant101"), Some(#variant101)) -assert eq(tFromJs("variant102"), Some(#variant102)) -assert eq(tFromJs("variant103"), Some(#variant103)) -assert eq(tFromJs("variant104"), Some(#variant104)) -assert eq(tFromJs("variant105"), Some(#variant105)) -assert eq(tFromJs("variant106"), Some(#variant106)) -assert eq(tFromJs("variant107"), Some(#variant107)) -assert eq(tFromJs("variant108"), Some(#variant108)) -assert eq(tFromJs("variant109"), Some(#variant109)) -assert eq(tFromJs("variant110"), Some(#variant110)) -assert eq(tFromJs("variant111"), Some(#variant111)) -assert eq(tFromJs("variant112"), Some(#variant112)) -assert eq(tFromJs("variant113"), Some(#variant113)) -assert eq(tFromJs("variant114"), Some(#variant114)) -assert eq(tFromJs("variant115"), Some(#variant115)) -assert eq(tFromJs("variant116"), Some(#variant116)) -assert eq(tFromJs("variant117"), Some(#variant117)) -assert eq(tFromJs("variant118"), Some(#variant118)) -assert eq(tFromJs("variant119"), Some(#variant119)) -assert eq(tFromJs("variant120"), Some(#variant120)) -assert eq(tFromJs("variant121"), Some(#variant121)) -assert eq(tFromJs("variant122"), Some(#variant122)) -assert eq(tFromJs("variant123"), Some(#variant123)) -assert eq(tFromJs("variant124"), Some(#variant124)) -assert eq(tFromJs("variant125"), Some(#variant125)) -assert eq(tFromJs("variant126"), Some(#variant126)) -assert eq(tFromJs("variant127"), Some(#variant127)) -assert eq(tFromJs("variant128"), Some(#variant128)) -assert eq(tFromJs("variant129"), Some(#variant129)) -assert eq(tFromJs("variant130"), Some(#variant130)) -assert eq(tFromJs("variant131"), Some(#variant131)) -assert eq(tFromJs("variant132"), Some(#variant132)) -assert eq(tFromJs("variant133"), Some(#variant133)) -assert eq(tFromJs("variant134"), Some(#variant134)) -assert eq(tFromJs("variant135"), Some(#variant135)) -assert eq(tFromJs("variant136"), Some(#variant136)) -assert eq(tFromJs("variant137"), Some(#variant137)) -assert eq(tFromJs("variant138"), Some(#variant138)) -assert eq(tFromJs("variant139"), Some(#variant139)) -assert eq(tFromJs("variant140"), Some(#variant140)) -assert eq(tFromJs("variant141"), Some(#variant141)) -assert eq(tFromJs("variant142"), Some(#variant142)) -assert eq(tFromJs("variant143"), Some(#variant143)) -assert eq(tFromJs("variant144"), Some(#variant144)) -assert eq(tFromJs("variant145"), Some(#variant145)) -assert eq(tFromJs("variant146"), Some(#variant146)) -assert eq(tFromJs("variant147"), Some(#variant147)) -assert eq(tFromJs("variant148"), Some(#variant148)) -assert eq(tFromJs("variant149"), Some(#variant149)) -assert eq(tFromJs("variant150"), Some(#variant150)) -assert eq(tFromJs("variant151"), Some(#variant151)) -assert eq(tFromJs("variant152"), Some(#variant152)) -assert eq(tFromJs("variant153"), Some(#variant153)) -assert eq(tFromJs("variant154"), Some(#variant154)) -assert eq(tFromJs("variant155"), Some(#variant155)) -assert eq(tFromJs("variant156"), Some(#variant156)) -assert eq(tFromJs("variant157"), Some(#variant157)) -assert eq(tFromJs("variant158"), Some(#variant158)) -assert eq(tFromJs("variant159"), Some(#variant159)) -assert eq(tFromJs("variant160"), Some(#variant160)) -assert eq(tFromJs("variant161"), Some(#variant161)) -assert eq(tFromJs("variant162"), Some(#variant162)) -assert eq(tFromJs("variant163"), Some(#variant163)) -assert eq(tFromJs("variant164"), Some(#variant164)) -assert eq(tFromJs("variant165"), Some(#variant165)) -assert eq(tFromJs("variant166"), Some(#variant166)) -assert eq(tFromJs("variant167"), Some(#variant167)) -assert eq(tFromJs("variant168"), Some(#variant168)) -assert eq(tFromJs("variant169"), Some(#variant169)) -assert eq(tFromJs("variant170"), Some(#variant170)) -assert eq(tFromJs("variant171"), Some(#variant171)) -assert eq(tFromJs("variant172"), Some(#variant172)) -assert eq(tFromJs("variant173"), Some(#variant173)) -assert eq(tFromJs("variant174"), Some(#variant174)) -assert eq(tFromJs("variant175"), Some(#variant175)) -assert eq(tFromJs("variant176"), Some(#variant176)) -assert eq(tFromJs("variant177"), Some(#variant177)) -assert eq(tFromJs("variant178"), Some(#variant178)) -assert eq(tFromJs("variant179"), Some(#variant179)) -assert eq(tFromJs("variant180"), Some(#variant180)) -assert eq(tFromJs("variant181"), Some(#variant181)) -assert eq(tFromJs("variant182"), Some(#variant182)) -assert eq(tFromJs("variant183"), Some(#variant183)) -assert eq(tFromJs("variant184"), Some(#variant184)) -assert eq(tFromJs("variant185"), Some(#variant185)) -assert eq(tFromJs("variant186"), Some(#variant186)) -assert eq(tFromJs("variant187"), Some(#variant187)) -assert eq(tFromJs("variant188"), Some(#variant188)) -assert eq(tFromJs("variant189"), Some(#variant189)) -assert eq(tFromJs("variant190"), Some(#variant190)) -assert eq(tFromJs("variant191"), Some(#variant191)) -assert eq(tFromJs("variant192"), Some(#variant192)) -assert eq(tFromJs("variant193"), Some(#variant193)) -assert eq(tFromJs("variant194"), Some(#variant194)) -assert eq(tFromJs("variant195"), Some(#variant195)) -assert eq(tFromJs("variant196"), Some(#variant196)) -assert eq(tFromJs("variant197"), Some(#variant197)) -assert eq(tFromJs("variant198"), Some(#variant198)) -assert eq(tFromJs("variant199"), Some(#variant199)) -assert eq(tFromJs("variant200"), Some(#variant200)) -assert eq(tFromJs("variant201"), Some(#variant201)) -assert eq(tFromJs("variant202"), Some(#variant202)) -assert eq(tFromJs("variant203"), Some(#variant203)) -assert eq(tFromJs("variant204"), Some(#variant204)) -assert eq(tFromJs("variant205"), Some(#variant205)) -assert eq(tFromJs("variant206"), Some(#variant206)) -assert eq(tFromJs("variant207"), Some(#variant207)) -assert eq(tFromJs("variant208"), Some(#variant208)) -assert eq(tFromJs("variant209"), Some(#variant209)) -assert eq(tFromJs("variant210"), Some(#variant210)) -assert eq(tFromJs("variant211"), Some(#variant211)) -assert eq(tFromJs("variant212"), Some(#variant212)) -assert eq(tFromJs("variant213"), Some(#variant213)) -assert eq(tFromJs("variant214"), Some(#variant214)) -assert eq(tFromJs("variant215"), Some(#variant215)) -assert eq(tFromJs("variant216"), Some(#variant216)) -assert eq(tFromJs("variant217"), Some(#variant217)) -assert eq(tFromJs("variant218"), Some(#variant218)) -assert eq(tFromJs("variant219"), Some(#variant219)) -assert eq(tFromJs("variant220"), Some(#variant220)) -assert eq(tFromJs("variant221"), Some(#variant221)) -assert eq(tFromJs("variant222"), Some(#variant222)) -assert eq(tFromJs("variant223"), Some(#variant223)) -assert eq(tFromJs("variant224"), Some(#variant224)) -assert eq(tFromJs("variant225"), Some(#variant225)) -assert eq(tFromJs("variant226"), Some(#variant226)) -assert eq(tFromJs("variant227"), Some(#variant227)) -assert eq(tFromJs("variant228"), Some(#variant228)) -assert eq(tFromJs("variant229"), Some(#variant229)) -assert eq(tFromJs("variant230"), Some(#variant230)) -assert eq(tFromJs("variant231"), Some(#variant231)) -assert eq(tFromJs("variant232"), Some(#variant232)) -assert eq(tFromJs("variant233"), Some(#variant233)) -assert eq(tFromJs("variant234"), Some(#variant234)) -assert eq(tFromJs("variant235"), Some(#variant235)) -assert eq(tFromJs("variant236"), Some(#variant236)) -assert eq(tFromJs("variant237"), Some(#variant237)) -assert eq(tFromJs("variant238"), Some(#variant238)) -assert eq(tFromJs("variant239"), Some(#variant239)) -assert eq(tFromJs("variant240"), Some(#variant240)) -assert eq(tFromJs("variant241"), Some(#variant241)) -assert eq(tFromJs("variant242"), Some(#variant242)) -assert eq(tFromJs("variant243"), Some(#variant243)) -assert eq(tFromJs("variant244"), Some(#variant244)) -assert eq(tFromJs("variant245"), Some(#variant245)) -assert eq(tFromJs("variant246"), Some(#variant246)) -assert eq(tFromJs("variant247"), Some(#variant247)) -assert eq(tFromJs("variant248"), Some(#variant248)) -assert eq(tFromJs("variant249"), Some(#variant249)) -assert eq(tFromJs("variant250"), Some(#variant250)) -assert eq(tFromJs("variant251"), Some(#variant251)) -assert eq(tFromJs("variant252"), Some(#variant252)) -assert eq(tFromJs("variant253"), Some(#variant253)) -assert eq(tFromJs("variant254"), Some(#variant254)) -assert eq(tFromJs("variant255"), Some(#variant255)) -assert eq(tFromJs("variant256"), Some(#variant256)) -assert eq(tFromJs("variant257"), Some(#variant257)) -assert eq(tFromJs("variant258"), Some(#variant258)) -assert eq(tFromJs("variant259"), Some(#variant259)) -assert eq(tFromJs("variant260"), Some(#variant260)) -assert eq(tFromJs("variant261"), Some(#variant261)) -assert eq(tFromJs("variant262"), Some(#variant262)) -assert eq(tFromJs("variant263"), Some(#variant263)) -assert eq(tFromJs("variant264"), Some(#variant264)) -assert eq(tFromJs("variant265"), Some(#variant265)) -assert eq(tFromJs("variant266"), Some(#variant266)) -assert eq(tFromJs("variant267"), Some(#variant267)) -assert eq(tFromJs("variant268"), Some(#variant268)) -assert eq(tFromJs("variant269"), Some(#variant269)) -assert eq(tFromJs("variant270"), Some(#variant270)) -assert eq(tFromJs("variant271"), Some(#variant271)) -assert eq(tFromJs("variant272"), Some(#variant272)) -assert eq(tFromJs("variant273"), Some(#variant273)) -assert eq(tFromJs("variant274"), Some(#variant274)) -assert eq(tFromJs("variant275"), Some(#variant275)) -assert eq(tFromJs("variant276"), Some(#variant276)) -assert eq(tFromJs("variant277"), Some(#variant277)) -assert eq(tFromJs("variant278"), Some(#variant278)) -assert eq(tFromJs("variant279"), Some(#variant279)) -assert eq(tFromJs("variant280"), Some(#variant280)) -assert eq(tFromJs("variant281"), Some(#variant281)) -assert eq(tFromJs("variant282"), Some(#variant282)) -assert eq(tFromJs("variant283"), Some(#variant283)) -assert eq(tFromJs("variant284"), Some(#variant284)) -assert eq(tFromJs("variant285"), Some(#variant285)) -assert eq(tFromJs("variant286"), Some(#variant286)) -assert eq(tFromJs("variant287"), Some(#variant287)) -assert eq(tFromJs("variant288"), Some(#variant288)) -assert eq(tFromJs("variant289"), Some(#variant289)) -assert eq(tFromJs("variant290"), Some(#variant290)) -assert eq(tFromJs("variant291"), Some(#variant291)) -assert eq(tFromJs("variant292"), Some(#variant292)) -assert eq(tFromJs("variant293"), Some(#variant293)) -assert eq(tFromJs("variant294"), Some(#variant294)) -assert eq(tFromJs("variant295"), Some(#variant295)) -assert eq(tFromJs("variant296"), Some(#variant296)) -assert eq(tFromJs("variant297"), Some(#variant297)) -assert eq(tFromJs("variant298"), Some(#variant298)) -assert eq(tFromJs("variant299"), Some(#variant299)) -assert eq(tFromJs("xx"), None) +assert(tToJs(#variant0) == "variant0") +assert(tToJs(#variant1) == "variant1") +assert(tToJs(#variant2) == "variant2") +assert(tToJs(#variant3) == "variant3") +assert(tToJs(#variant4) == "variant4") +assert(tToJs(#variant5) == "variant5") +assert(tToJs(#variant6) == "variant6") +assert(tToJs(#variant7) == "variant7") +assert(tToJs(#variant8) == "variant8") +assert(tToJs(#variant9) == "variant9") +assert(tToJs(#variant10) == "variant10") +assert(tToJs(#variant11) == "variant11") +assert(tToJs(#variant12) == "variant12") +assert(tToJs(#variant13) == "variant13") +assert(tToJs(#variant14) == "variant14") +assert(tToJs(#variant15) == "variant15") +assert(tToJs(#variant16) == "variant16") +assert(tToJs(#variant17) == "variant17") +assert(tToJs(#variant18) == "variant18") +assert(tToJs(#variant19) == "variant19") +assert(tToJs(#variant20) == "variant20") +assert(tToJs(#variant21) == "variant21") +assert(tToJs(#variant22) == "variant22") +assert(tToJs(#variant23) == "variant23") +assert(tToJs(#variant24) == "variant24") +assert(tToJs(#variant25) == "variant25") +assert(tToJs(#variant26) == "variant26") +assert(tToJs(#variant27) == "variant27") +assert(tToJs(#variant28) == "variant28") +assert(tToJs(#variant29) == "variant29") +assert(tToJs(#variant30) == "variant30") +assert(tToJs(#variant31) == "variant31") +assert(tToJs(#variant32) == "variant32") +assert(tToJs(#variant33) == "variant33") +assert(tToJs(#variant34) == "variant34") +assert(tToJs(#variant35) == "variant35") +assert(tToJs(#variant36) == "variant36") +assert(tToJs(#variant37) == "variant37") +assert(tToJs(#variant38) == "variant38") +assert(tToJs(#variant39) == "variant39") +assert(tToJs(#variant40) == "variant40") +assert(tToJs(#variant41) == "variant41") +assert(tToJs(#variant42) == "variant42") +assert(tToJs(#variant43) == "variant43") +assert(tToJs(#variant44) == "variant44") +assert(tToJs(#variant45) == "variant45") +assert(tToJs(#variant46) == "variant46") +assert(tToJs(#variant47) == "variant47") +assert(tToJs(#variant48) == "variant48") +assert(tToJs(#variant49) == "variant49") +assert(tToJs(#variant50) == "variant50") +assert(tToJs(#variant51) == "variant51") +assert(tToJs(#variant52) == "variant52") +assert(tToJs(#variant53) == "variant53") +assert(tToJs(#variant54) == "variant54") +assert(tToJs(#variant55) == "variant55") +assert(tToJs(#variant56) == "variant56") +assert(tToJs(#variant57) == "variant57") +assert(tToJs(#variant58) == "variant58") +assert(tToJs(#variant59) == "variant59") +assert(tToJs(#variant60) == "variant60") +assert(tToJs(#variant61) == "variant61") +assert(tToJs(#variant62) == "variant62") +assert(tToJs(#variant63) == "variant63") +assert(tToJs(#variant64) == "variant64") +assert(tToJs(#variant65) == "variant65") +assert(tToJs(#variant66) == "variant66") +assert(tToJs(#variant67) == "variant67") +assert(tToJs(#variant68) == "variant68") +assert(tToJs(#variant69) == "variant69") +assert(tToJs(#variant70) == "variant70") +assert(tToJs(#variant71) == "variant71") +assert(tToJs(#variant72) == "variant72") +assert(tToJs(#variant73) == "variant73") +assert(tToJs(#variant74) == "variant74") +assert(tToJs(#variant75) == "variant75") +assert(tToJs(#variant76) == "variant76") +assert(tToJs(#variant77) == "variant77") +assert(tToJs(#variant78) == "variant78") +assert(tToJs(#variant79) == "variant79") +assert(tToJs(#variant80) == "variant80") +assert(tToJs(#variant81) == "variant81") +assert(tToJs(#variant82) == "variant82") +assert(tToJs(#variant83) == "variant83") +assert(tToJs(#variant84) == "variant84") +assert(tToJs(#variant85) == "variant85") +assert(tToJs(#variant86) == "variant86") +assert(tToJs(#variant87) == "variant87") +assert(tToJs(#variant88) == "variant88") +assert(tToJs(#variant89) == "variant89") +assert(tToJs(#variant90) == "variant90") +assert(tToJs(#variant91) == "variant91") +assert(tToJs(#variant92) == "variant92") +assert(tToJs(#variant93) == "variant93") +assert(tToJs(#variant94) == "variant94") +assert(tToJs(#variant95) == "variant95") +assert(tToJs(#variant96) == "variant96") +assert(tToJs(#variant97) == "variant97") +assert(tToJs(#variant98) == "variant98") +assert(tToJs(#variant99) == "variant99") +assert(tToJs(#variant100) == "variant100") +assert(tToJs(#variant101) == "variant101") +assert(tToJs(#variant102) == "variant102") +assert(tToJs(#variant103) == "variant103") +assert(tToJs(#variant104) == "variant104") +assert(tToJs(#variant105) == "variant105") +assert(tToJs(#variant106) == "variant106") +assert(tToJs(#variant107) == "variant107") +assert(tToJs(#variant108) == "variant108") +assert(tToJs(#variant109) == "variant109") +assert(tToJs(#variant110) == "variant110") +assert(tToJs(#variant111) == "variant111") +assert(tToJs(#variant112) == "variant112") +assert(tToJs(#variant113) == "variant113") +assert(tToJs(#variant114) == "variant114") +assert(tToJs(#variant115) == "variant115") +assert(tToJs(#variant116) == "variant116") +assert(tToJs(#variant117) == "variant117") +assert(tToJs(#variant118) == "variant118") +assert(tToJs(#variant119) == "variant119") +assert(tToJs(#variant120) == "variant120") +assert(tToJs(#variant121) == "variant121") +assert(tToJs(#variant122) == "variant122") +assert(tToJs(#variant123) == "variant123") +assert(tToJs(#variant124) == "variant124") +assert(tToJs(#variant125) == "variant125") +assert(tToJs(#variant126) == "variant126") +assert(tToJs(#variant127) == "variant127") +assert(tToJs(#variant128) == "variant128") +assert(tToJs(#variant129) == "variant129") +assert(tToJs(#variant130) == "variant130") +assert(tToJs(#variant131) == "variant131") +assert(tToJs(#variant132) == "variant132") +assert(tToJs(#variant133) == "variant133") +assert(tToJs(#variant134) == "variant134") +assert(tToJs(#variant135) == "variant135") +assert(tToJs(#variant136) == "variant136") +assert(tToJs(#variant137) == "variant137") +assert(tToJs(#variant138) == "variant138") +assert(tToJs(#variant139) == "variant139") +assert(tToJs(#variant140) == "variant140") +assert(tToJs(#variant141) == "variant141") +assert(tToJs(#variant142) == "variant142") +assert(tToJs(#variant143) == "variant143") +assert(tToJs(#variant144) == "variant144") +assert(tToJs(#variant145) == "variant145") +assert(tToJs(#variant146) == "variant146") +assert(tToJs(#variant147) == "variant147") +assert(tToJs(#variant148) == "variant148") +assert(tToJs(#variant149) == "variant149") +assert(tToJs(#variant150) == "variant150") +assert(tToJs(#variant151) == "variant151") +assert(tToJs(#variant152) == "variant152") +assert(tToJs(#variant153) == "variant153") +assert(tToJs(#variant154) == "variant154") +assert(tToJs(#variant155) == "variant155") +assert(tToJs(#variant156) == "variant156") +assert(tToJs(#variant157) == "variant157") +assert(tToJs(#variant158) == "variant158") +assert(tToJs(#variant159) == "variant159") +assert(tToJs(#variant160) == "variant160") +assert(tToJs(#variant161) == "variant161") +assert(tToJs(#variant162) == "variant162") +assert(tToJs(#variant163) == "variant163") +assert(tToJs(#variant164) == "variant164") +assert(tToJs(#variant165) == "variant165") +assert(tToJs(#variant166) == "variant166") +assert(tToJs(#variant167) == "variant167") +assert(tToJs(#variant168) == "variant168") +assert(tToJs(#variant169) == "variant169") +assert(tToJs(#variant170) == "variant170") +assert(tToJs(#variant171) == "variant171") +assert(tToJs(#variant172) == "variant172") +assert(tToJs(#variant173) == "variant173") +assert(tToJs(#variant174) == "variant174") +assert(tToJs(#variant175) == "variant175") +assert(tToJs(#variant176) == "variant176") +assert(tToJs(#variant177) == "variant177") +assert(tToJs(#variant178) == "variant178") +assert(tToJs(#variant179) == "variant179") +assert(tToJs(#variant180) == "variant180") +assert(tToJs(#variant181) == "variant181") +assert(tToJs(#variant182) == "variant182") +assert(tToJs(#variant183) == "variant183") +assert(tToJs(#variant184) == "variant184") +assert(tToJs(#variant185) == "variant185") +assert(tToJs(#variant186) == "variant186") +assert(tToJs(#variant187) == "variant187") +assert(tToJs(#variant188) == "variant188") +assert(tToJs(#variant189) == "variant189") +assert(tToJs(#variant190) == "variant190") +assert(tToJs(#variant191) == "variant191") +assert(tToJs(#variant192) == "variant192") +assert(tToJs(#variant193) == "variant193") +assert(tToJs(#variant194) == "variant194") +assert(tToJs(#variant195) == "variant195") +assert(tToJs(#variant196) == "variant196") +assert(tToJs(#variant197) == "variant197") +assert(tToJs(#variant198) == "variant198") +assert(tToJs(#variant199) == "variant199") +assert(tToJs(#variant200) == "variant200") +assert(tToJs(#variant201) == "variant201") +assert(tToJs(#variant202) == "variant202") +assert(tToJs(#variant203) == "variant203") +assert(tToJs(#variant204) == "variant204") +assert(tToJs(#variant205) == "variant205") +assert(tToJs(#variant206) == "variant206") +assert(tToJs(#variant207) == "variant207") +assert(tToJs(#variant208) == "variant208") +assert(tToJs(#variant209) == "variant209") +assert(tToJs(#variant210) == "variant210") +assert(tToJs(#variant211) == "variant211") +assert(tToJs(#variant212) == "variant212") +assert(tToJs(#variant213) == "variant213") +assert(tToJs(#variant214) == "variant214") +assert(tToJs(#variant215) == "variant215") +assert(tToJs(#variant216) == "variant216") +assert(tToJs(#variant217) == "variant217") +assert(tToJs(#variant218) == "variant218") +assert(tToJs(#variant219) == "variant219") +assert(tToJs(#variant220) == "variant220") +assert(tToJs(#variant221) == "variant221") +assert(tToJs(#variant222) == "variant222") +assert(tToJs(#variant223) == "variant223") +assert(tToJs(#variant224) == "variant224") +assert(tToJs(#variant225) == "variant225") +assert(tToJs(#variant226) == "variant226") +assert(tToJs(#variant227) == "variant227") +assert(tToJs(#variant228) == "variant228") +assert(tToJs(#variant229) == "variant229") +assert(tToJs(#variant230) == "variant230") +assert(tToJs(#variant231) == "variant231") +assert(tToJs(#variant232) == "variant232") +assert(tToJs(#variant233) == "variant233") +assert(tToJs(#variant234) == "variant234") +assert(tToJs(#variant235) == "variant235") +assert(tToJs(#variant236) == "variant236") +assert(tToJs(#variant237) == "variant237") +assert(tToJs(#variant238) == "variant238") +assert(tToJs(#variant239) == "variant239") +assert(tToJs(#variant240) == "variant240") +assert(tToJs(#variant241) == "variant241") +assert(tToJs(#variant242) == "variant242") +assert(tToJs(#variant243) == "variant243") +assert(tToJs(#variant244) == "variant244") +assert(tToJs(#variant245) == "variant245") +assert(tToJs(#variant246) == "variant246") +assert(tToJs(#variant247) == "variant247") +assert(tToJs(#variant248) == "variant248") +assert(tToJs(#variant249) == "variant249") +assert(tToJs(#variant250) == "variant250") +assert(tToJs(#variant251) == "variant251") +assert(tToJs(#variant252) == "variant252") +assert(tToJs(#variant253) == "variant253") +assert(tToJs(#variant254) == "variant254") +assert(tToJs(#variant255) == "variant255") +assert(tToJs(#variant256) == "variant256") +assert(tToJs(#variant257) == "variant257") +assert(tToJs(#variant258) == "variant258") +assert(tToJs(#variant259) == "variant259") +assert(tToJs(#variant260) == "variant260") +assert(tToJs(#variant261) == "variant261") +assert(tToJs(#variant262) == "variant262") +assert(tToJs(#variant263) == "variant263") +assert(tToJs(#variant264) == "variant264") +assert(tToJs(#variant265) == "variant265") +assert(tToJs(#variant266) == "variant266") +assert(tToJs(#variant267) == "variant267") +assert(tToJs(#variant268) == "variant268") +assert(tToJs(#variant269) == "variant269") +assert(tToJs(#variant270) == "variant270") +assert(tToJs(#variant271) == "variant271") +assert(tToJs(#variant272) == "variant272") +assert(tToJs(#variant273) == "variant273") +assert(tToJs(#variant274) == "variant274") +assert(tToJs(#variant275) == "variant275") +assert(tToJs(#variant276) == "variant276") +assert(tToJs(#variant277) == "variant277") +assert(tToJs(#variant278) == "variant278") +assert(tToJs(#variant279) == "variant279") +assert(tToJs(#variant280) == "variant280") +assert(tToJs(#variant281) == "variant281") +assert(tToJs(#variant282) == "variant282") +assert(tToJs(#variant283) == "variant283") +assert(tToJs(#variant284) == "variant284") +assert(tToJs(#variant285) == "variant285") +assert(tToJs(#variant286) == "variant286") +assert(tToJs(#variant287) == "variant287") +assert(tToJs(#variant288) == "variant288") +assert(tToJs(#variant289) == "variant289") +assert(tToJs(#variant290) == "variant290") +assert(tToJs(#variant291) == "variant291") +assert(tToJs(#variant292) == "variant292") +assert(tToJs(#variant293) == "variant293") +assert(tToJs(#variant294) == "variant294") +assert(tToJs(#variant295) == "variant295") +assert(tToJs(#variant296) == "variant296") +assert(tToJs(#variant297) == "variant297") +assert(tToJs(#variant298) == "variant298") +assert(tToJs(#variant299) == "variant299") +assert(eq(tFromJs("variant0"), Some(#variant0))) +assert(eq(tFromJs("variant1"), Some(#variant1))) +assert(eq(tFromJs("variant2"), Some(#variant2))) +assert(eq(tFromJs("variant3"), Some(#variant3))) +assert(eq(tFromJs("variant4"), Some(#variant4))) +assert(eq(tFromJs("variant5"), Some(#variant5))) +assert(eq(tFromJs("variant6"), Some(#variant6))) +assert(eq(tFromJs("variant7"), Some(#variant7))) +assert(eq(tFromJs("variant8"), Some(#variant8))) +assert(eq(tFromJs("variant9"), Some(#variant9))) +assert(eq(tFromJs("variant10"), Some(#variant10))) +assert(eq(tFromJs("variant11"), Some(#variant11))) +assert(eq(tFromJs("variant12"), Some(#variant12))) +assert(eq(tFromJs("variant13"), Some(#variant13))) +assert(eq(tFromJs("variant14"), Some(#variant14))) +assert(eq(tFromJs("variant15"), Some(#variant15))) +assert(eq(tFromJs("variant16"), Some(#variant16))) +assert(eq(tFromJs("variant17"), Some(#variant17))) +assert(eq(tFromJs("variant18"), Some(#variant18))) +assert(eq(tFromJs("variant19"), Some(#variant19))) +assert(eq(tFromJs("variant20"), Some(#variant20))) +assert(eq(tFromJs("variant21"), Some(#variant21))) +assert(eq(tFromJs("variant22"), Some(#variant22))) +assert(eq(tFromJs("variant23"), Some(#variant23))) +assert(eq(tFromJs("variant24"), Some(#variant24))) +assert(eq(tFromJs("variant25"), Some(#variant25))) +assert(eq(tFromJs("variant26"), Some(#variant26))) +assert(eq(tFromJs("variant27"), Some(#variant27))) +assert(eq(tFromJs("variant28"), Some(#variant28))) +assert(eq(tFromJs("variant29"), Some(#variant29))) +assert(eq(tFromJs("variant30"), Some(#variant30))) +assert(eq(tFromJs("variant31"), Some(#variant31))) +assert(eq(tFromJs("variant32"), Some(#variant32))) +assert(eq(tFromJs("variant33"), Some(#variant33))) +assert(eq(tFromJs("variant34"), Some(#variant34))) +assert(eq(tFromJs("variant35"), Some(#variant35))) +assert(eq(tFromJs("variant36"), Some(#variant36))) +assert(eq(tFromJs("variant37"), Some(#variant37))) +assert(eq(tFromJs("variant38"), Some(#variant38))) +assert(eq(tFromJs("variant39"), Some(#variant39))) +assert(eq(tFromJs("variant40"), Some(#variant40))) +assert(eq(tFromJs("variant41"), Some(#variant41))) +assert(eq(tFromJs("variant42"), Some(#variant42))) +assert(eq(tFromJs("variant43"), Some(#variant43))) +assert(eq(tFromJs("variant44"), Some(#variant44))) +assert(eq(tFromJs("variant45"), Some(#variant45))) +assert(eq(tFromJs("variant46"), Some(#variant46))) +assert(eq(tFromJs("variant47"), Some(#variant47))) +assert(eq(tFromJs("variant48"), Some(#variant48))) +assert(eq(tFromJs("variant49"), Some(#variant49))) +assert(eq(tFromJs("variant50"), Some(#variant50))) +assert(eq(tFromJs("variant51"), Some(#variant51))) +assert(eq(tFromJs("variant52"), Some(#variant52))) +assert(eq(tFromJs("variant53"), Some(#variant53))) +assert(eq(tFromJs("variant54"), Some(#variant54))) +assert(eq(tFromJs("variant55"), Some(#variant55))) +assert(eq(tFromJs("variant56"), Some(#variant56))) +assert(eq(tFromJs("variant57"), Some(#variant57))) +assert(eq(tFromJs("variant58"), Some(#variant58))) +assert(eq(tFromJs("variant59"), Some(#variant59))) +assert(eq(tFromJs("variant60"), Some(#variant60))) +assert(eq(tFromJs("variant61"), Some(#variant61))) +assert(eq(tFromJs("variant62"), Some(#variant62))) +assert(eq(tFromJs("variant63"), Some(#variant63))) +assert(eq(tFromJs("variant64"), Some(#variant64))) +assert(eq(tFromJs("variant65"), Some(#variant65))) +assert(eq(tFromJs("variant66"), Some(#variant66))) +assert(eq(tFromJs("variant67"), Some(#variant67))) +assert(eq(tFromJs("variant68"), Some(#variant68))) +assert(eq(tFromJs("variant69"), Some(#variant69))) +assert(eq(tFromJs("variant70"), Some(#variant70))) +assert(eq(tFromJs("variant71"), Some(#variant71))) +assert(eq(tFromJs("variant72"), Some(#variant72))) +assert(eq(tFromJs("variant73"), Some(#variant73))) +assert(eq(tFromJs("variant74"), Some(#variant74))) +assert(eq(tFromJs("variant75"), Some(#variant75))) +assert(eq(tFromJs("variant76"), Some(#variant76))) +assert(eq(tFromJs("variant77"), Some(#variant77))) +assert(eq(tFromJs("variant78"), Some(#variant78))) +assert(eq(tFromJs("variant79"), Some(#variant79))) +assert(eq(tFromJs("variant80"), Some(#variant80))) +assert(eq(tFromJs("variant81"), Some(#variant81))) +assert(eq(tFromJs("variant82"), Some(#variant82))) +assert(eq(tFromJs("variant83"), Some(#variant83))) +assert(eq(tFromJs("variant84"), Some(#variant84))) +assert(eq(tFromJs("variant85"), Some(#variant85))) +assert(eq(tFromJs("variant86"), Some(#variant86))) +assert(eq(tFromJs("variant87"), Some(#variant87))) +assert(eq(tFromJs("variant88"), Some(#variant88))) +assert(eq(tFromJs("variant89"), Some(#variant89))) +assert(eq(tFromJs("variant90"), Some(#variant90))) +assert(eq(tFromJs("variant91"), Some(#variant91))) +assert(eq(tFromJs("variant92"), Some(#variant92))) +assert(eq(tFromJs("variant93"), Some(#variant93))) +assert(eq(tFromJs("variant94"), Some(#variant94))) +assert(eq(tFromJs("variant95"), Some(#variant95))) +assert(eq(tFromJs("variant96"), Some(#variant96))) +assert(eq(tFromJs("variant97"), Some(#variant97))) +assert(eq(tFromJs("variant98"), Some(#variant98))) +assert(eq(tFromJs("variant99"), Some(#variant99))) +assert(eq(tFromJs("variant100"), Some(#variant100))) +assert(eq(tFromJs("variant101"), Some(#variant101))) +assert(eq(tFromJs("variant102"), Some(#variant102))) +assert(eq(tFromJs("variant103"), Some(#variant103))) +assert(eq(tFromJs("variant104"), Some(#variant104))) +assert(eq(tFromJs("variant105"), Some(#variant105))) +assert(eq(tFromJs("variant106"), Some(#variant106))) +assert(eq(tFromJs("variant107"), Some(#variant107))) +assert(eq(tFromJs("variant108"), Some(#variant108))) +assert(eq(tFromJs("variant109"), Some(#variant109))) +assert(eq(tFromJs("variant110"), Some(#variant110))) +assert(eq(tFromJs("variant111"), Some(#variant111))) +assert(eq(tFromJs("variant112"), Some(#variant112))) +assert(eq(tFromJs("variant113"), Some(#variant113))) +assert(eq(tFromJs("variant114"), Some(#variant114))) +assert(eq(tFromJs("variant115"), Some(#variant115))) +assert(eq(tFromJs("variant116"), Some(#variant116))) +assert(eq(tFromJs("variant117"), Some(#variant117))) +assert(eq(tFromJs("variant118"), Some(#variant118))) +assert(eq(tFromJs("variant119"), Some(#variant119))) +assert(eq(tFromJs("variant120"), Some(#variant120))) +assert(eq(tFromJs("variant121"), Some(#variant121))) +assert(eq(tFromJs("variant122"), Some(#variant122))) +assert(eq(tFromJs("variant123"), Some(#variant123))) +assert(eq(tFromJs("variant124"), Some(#variant124))) +assert(eq(tFromJs("variant125"), Some(#variant125))) +assert(eq(tFromJs("variant126"), Some(#variant126))) +assert(eq(tFromJs("variant127"), Some(#variant127))) +assert(eq(tFromJs("variant128"), Some(#variant128))) +assert(eq(tFromJs("variant129"), Some(#variant129))) +assert(eq(tFromJs("variant130"), Some(#variant130))) +assert(eq(tFromJs("variant131"), Some(#variant131))) +assert(eq(tFromJs("variant132"), Some(#variant132))) +assert(eq(tFromJs("variant133"), Some(#variant133))) +assert(eq(tFromJs("variant134"), Some(#variant134))) +assert(eq(tFromJs("variant135"), Some(#variant135))) +assert(eq(tFromJs("variant136"), Some(#variant136))) +assert(eq(tFromJs("variant137"), Some(#variant137))) +assert(eq(tFromJs("variant138"), Some(#variant138))) +assert(eq(tFromJs("variant139"), Some(#variant139))) +assert(eq(tFromJs("variant140"), Some(#variant140))) +assert(eq(tFromJs("variant141"), Some(#variant141))) +assert(eq(tFromJs("variant142"), Some(#variant142))) +assert(eq(tFromJs("variant143"), Some(#variant143))) +assert(eq(tFromJs("variant144"), Some(#variant144))) +assert(eq(tFromJs("variant145"), Some(#variant145))) +assert(eq(tFromJs("variant146"), Some(#variant146))) +assert(eq(tFromJs("variant147"), Some(#variant147))) +assert(eq(tFromJs("variant148"), Some(#variant148))) +assert(eq(tFromJs("variant149"), Some(#variant149))) +assert(eq(tFromJs("variant150"), Some(#variant150))) +assert(eq(tFromJs("variant151"), Some(#variant151))) +assert(eq(tFromJs("variant152"), Some(#variant152))) +assert(eq(tFromJs("variant153"), Some(#variant153))) +assert(eq(tFromJs("variant154"), Some(#variant154))) +assert(eq(tFromJs("variant155"), Some(#variant155))) +assert(eq(tFromJs("variant156"), Some(#variant156))) +assert(eq(tFromJs("variant157"), Some(#variant157))) +assert(eq(tFromJs("variant158"), Some(#variant158))) +assert(eq(tFromJs("variant159"), Some(#variant159))) +assert(eq(tFromJs("variant160"), Some(#variant160))) +assert(eq(tFromJs("variant161"), Some(#variant161))) +assert(eq(tFromJs("variant162"), Some(#variant162))) +assert(eq(tFromJs("variant163"), Some(#variant163))) +assert(eq(tFromJs("variant164"), Some(#variant164))) +assert(eq(tFromJs("variant165"), Some(#variant165))) +assert(eq(tFromJs("variant166"), Some(#variant166))) +assert(eq(tFromJs("variant167"), Some(#variant167))) +assert(eq(tFromJs("variant168"), Some(#variant168))) +assert(eq(tFromJs("variant169"), Some(#variant169))) +assert(eq(tFromJs("variant170"), Some(#variant170))) +assert(eq(tFromJs("variant171"), Some(#variant171))) +assert(eq(tFromJs("variant172"), Some(#variant172))) +assert(eq(tFromJs("variant173"), Some(#variant173))) +assert(eq(tFromJs("variant174"), Some(#variant174))) +assert(eq(tFromJs("variant175"), Some(#variant175))) +assert(eq(tFromJs("variant176"), Some(#variant176))) +assert(eq(tFromJs("variant177"), Some(#variant177))) +assert(eq(tFromJs("variant178"), Some(#variant178))) +assert(eq(tFromJs("variant179"), Some(#variant179))) +assert(eq(tFromJs("variant180"), Some(#variant180))) +assert(eq(tFromJs("variant181"), Some(#variant181))) +assert(eq(tFromJs("variant182"), Some(#variant182))) +assert(eq(tFromJs("variant183"), Some(#variant183))) +assert(eq(tFromJs("variant184"), Some(#variant184))) +assert(eq(tFromJs("variant185"), Some(#variant185))) +assert(eq(tFromJs("variant186"), Some(#variant186))) +assert(eq(tFromJs("variant187"), Some(#variant187))) +assert(eq(tFromJs("variant188"), Some(#variant188))) +assert(eq(tFromJs("variant189"), Some(#variant189))) +assert(eq(tFromJs("variant190"), Some(#variant190))) +assert(eq(tFromJs("variant191"), Some(#variant191))) +assert(eq(tFromJs("variant192"), Some(#variant192))) +assert(eq(tFromJs("variant193"), Some(#variant193))) +assert(eq(tFromJs("variant194"), Some(#variant194))) +assert(eq(tFromJs("variant195"), Some(#variant195))) +assert(eq(tFromJs("variant196"), Some(#variant196))) +assert(eq(tFromJs("variant197"), Some(#variant197))) +assert(eq(tFromJs("variant198"), Some(#variant198))) +assert(eq(tFromJs("variant199"), Some(#variant199))) +assert(eq(tFromJs("variant200"), Some(#variant200))) +assert(eq(tFromJs("variant201"), Some(#variant201))) +assert(eq(tFromJs("variant202"), Some(#variant202))) +assert(eq(tFromJs("variant203"), Some(#variant203))) +assert(eq(tFromJs("variant204"), Some(#variant204))) +assert(eq(tFromJs("variant205"), Some(#variant205))) +assert(eq(tFromJs("variant206"), Some(#variant206))) +assert(eq(tFromJs("variant207"), Some(#variant207))) +assert(eq(tFromJs("variant208"), Some(#variant208))) +assert(eq(tFromJs("variant209"), Some(#variant209))) +assert(eq(tFromJs("variant210"), Some(#variant210))) +assert(eq(tFromJs("variant211"), Some(#variant211))) +assert(eq(tFromJs("variant212"), Some(#variant212))) +assert(eq(tFromJs("variant213"), Some(#variant213))) +assert(eq(tFromJs("variant214"), Some(#variant214))) +assert(eq(tFromJs("variant215"), Some(#variant215))) +assert(eq(tFromJs("variant216"), Some(#variant216))) +assert(eq(tFromJs("variant217"), Some(#variant217))) +assert(eq(tFromJs("variant218"), Some(#variant218))) +assert(eq(tFromJs("variant219"), Some(#variant219))) +assert(eq(tFromJs("variant220"), Some(#variant220))) +assert(eq(tFromJs("variant221"), Some(#variant221))) +assert(eq(tFromJs("variant222"), Some(#variant222))) +assert(eq(tFromJs("variant223"), Some(#variant223))) +assert(eq(tFromJs("variant224"), Some(#variant224))) +assert(eq(tFromJs("variant225"), Some(#variant225))) +assert(eq(tFromJs("variant226"), Some(#variant226))) +assert(eq(tFromJs("variant227"), Some(#variant227))) +assert(eq(tFromJs("variant228"), Some(#variant228))) +assert(eq(tFromJs("variant229"), Some(#variant229))) +assert(eq(tFromJs("variant230"), Some(#variant230))) +assert(eq(tFromJs("variant231"), Some(#variant231))) +assert(eq(tFromJs("variant232"), Some(#variant232))) +assert(eq(tFromJs("variant233"), Some(#variant233))) +assert(eq(tFromJs("variant234"), Some(#variant234))) +assert(eq(tFromJs("variant235"), Some(#variant235))) +assert(eq(tFromJs("variant236"), Some(#variant236))) +assert(eq(tFromJs("variant237"), Some(#variant237))) +assert(eq(tFromJs("variant238"), Some(#variant238))) +assert(eq(tFromJs("variant239"), Some(#variant239))) +assert(eq(tFromJs("variant240"), Some(#variant240))) +assert(eq(tFromJs("variant241"), Some(#variant241))) +assert(eq(tFromJs("variant242"), Some(#variant242))) +assert(eq(tFromJs("variant243"), Some(#variant243))) +assert(eq(tFromJs("variant244"), Some(#variant244))) +assert(eq(tFromJs("variant245"), Some(#variant245))) +assert(eq(tFromJs("variant246"), Some(#variant246))) +assert(eq(tFromJs("variant247"), Some(#variant247))) +assert(eq(tFromJs("variant248"), Some(#variant248))) +assert(eq(tFromJs("variant249"), Some(#variant249))) +assert(eq(tFromJs("variant250"), Some(#variant250))) +assert(eq(tFromJs("variant251"), Some(#variant251))) +assert(eq(tFromJs("variant252"), Some(#variant252))) +assert(eq(tFromJs("variant253"), Some(#variant253))) +assert(eq(tFromJs("variant254"), Some(#variant254))) +assert(eq(tFromJs("variant255"), Some(#variant255))) +assert(eq(tFromJs("variant256"), Some(#variant256))) +assert(eq(tFromJs("variant257"), Some(#variant257))) +assert(eq(tFromJs("variant258"), Some(#variant258))) +assert(eq(tFromJs("variant259"), Some(#variant259))) +assert(eq(tFromJs("variant260"), Some(#variant260))) +assert(eq(tFromJs("variant261"), Some(#variant261))) +assert(eq(tFromJs("variant262"), Some(#variant262))) +assert(eq(tFromJs("variant263"), Some(#variant263))) +assert(eq(tFromJs("variant264"), Some(#variant264))) +assert(eq(tFromJs("variant265"), Some(#variant265))) +assert(eq(tFromJs("variant266"), Some(#variant266))) +assert(eq(tFromJs("variant267"), Some(#variant267))) +assert(eq(tFromJs("variant268"), Some(#variant268))) +assert(eq(tFromJs("variant269"), Some(#variant269))) +assert(eq(tFromJs("variant270"), Some(#variant270))) +assert(eq(tFromJs("variant271"), Some(#variant271))) +assert(eq(tFromJs("variant272"), Some(#variant272))) +assert(eq(tFromJs("variant273"), Some(#variant273))) +assert(eq(tFromJs("variant274"), Some(#variant274))) +assert(eq(tFromJs("variant275"), Some(#variant275))) +assert(eq(tFromJs("variant276"), Some(#variant276))) +assert(eq(tFromJs("variant277"), Some(#variant277))) +assert(eq(tFromJs("variant278"), Some(#variant278))) +assert(eq(tFromJs("variant279"), Some(#variant279))) +assert(eq(tFromJs("variant280"), Some(#variant280))) +assert(eq(tFromJs("variant281"), Some(#variant281))) +assert(eq(tFromJs("variant282"), Some(#variant282))) +assert(eq(tFromJs("variant283"), Some(#variant283))) +assert(eq(tFromJs("variant284"), Some(#variant284))) +assert(eq(tFromJs("variant285"), Some(#variant285))) +assert(eq(tFromJs("variant286"), Some(#variant286))) +assert(eq(tFromJs("variant287"), Some(#variant287))) +assert(eq(tFromJs("variant288"), Some(#variant288))) +assert(eq(tFromJs("variant289"), Some(#variant289))) +assert(eq(tFromJs("variant290"), Some(#variant290))) +assert(eq(tFromJs("variant291"), Some(#variant291))) +assert(eq(tFromJs("variant292"), Some(#variant292))) +assert(eq(tFromJs("variant293"), Some(#variant293))) +assert(eq(tFromJs("variant294"), Some(#variant294))) +assert(eq(tFromJs("variant295"), Some(#variant295))) +assert(eq(tFromJs("variant296"), Some(#variant296))) +assert(eq(tFromJs("variant297"), Some(#variant297))) +assert(eq(tFromJs("variant298"), Some(#variant298))) +assert(eq(tFromJs("variant299"), Some(#variant299))) +assert(eq(tFromJs("xx"), None)) diff --git a/jscomp/test/bs_array_test.res b/jscomp/test/bs_array_test.res index 988680474d..dbb88eb2de 100644 --- a/jscomp/test/bs_array_test.res +++ b/jscomp/test/bs_array_test.res @@ -48,7 +48,7 @@ let () = { __LOC__, { let v = [1, 2] - assert A.set(v, 0, 0) + assert(A.set(v, 0, 0)) A.getExn(v, 0) == 0 }, ) @@ -56,7 +56,7 @@ let () = { __LOC__, { let v = [1, 2] - assert A.set(v, 1, 0) + assert(A.set(v, 1, 0)) A.getExn(v, 1) == 0 }, ) @@ -150,7 +150,7 @@ let addone = (. x) => x + 1 let makeMatrixExn = (sx, sy, init) => { /* let open A in */ - assert (sx >= 0 && sy >= 0) + assert(sx >= 0 && sy >= 0) let res = A.makeUninitializedUnsafe(sx) for x in 0 to sx - 1 { let initY = A.makeUninitializedUnsafe(sy) diff --git a/jscomp/test/bs_hashtbl_string_test.res b/jscomp/test/bs_hashtbl_string_test.res index 2d9c7b18e5..052c81ecd2 100644 --- a/jscomp/test/bs_hashtbl_string_test.res +++ b/jscomp/test/bs_hashtbl_string_test.res @@ -34,7 +34,7 @@ let bench = () => { N.set(empty, i, i) } for i in 0 to count { - assert mem(empty, i) + assert(mem(empty, i)) } N.logStats(empty) } @@ -58,7 +58,7 @@ let bench2 = (type t, m: Belt.Id.hashable) => { M.set(empty, string_of_int(i), i) } for i in 0 to count { - assert M.has(empty, string_of_int(i)) + assert(M.has(empty, string_of_int(i))) } for i in 0 to count { M.remove(empty, string_of_int(i)) @@ -78,7 +78,7 @@ let bench3 = (type t, m: Belt.Id.comparable) => { table := Md0.set(~cmp, table.contents, string_of_int(i), i) } for i in 0 to count { - assert Md0.has(~cmp, table.contents, string_of_int(i)) + assert(Md0.has(~cmp, table.contents, string_of_int(i))) } for i in 0 to count { table := Md0.remove(~cmp, table.contents, string_of_int(i)) @@ -95,12 +95,12 @@ let bench4 = () => { H.set(table, string_of_int(i), i) } for i in 0 to count { - assert H.has(table, string_of_int(i)) + assert(H.has(table, string_of_int(i))) } for i in 0 to count { H.remove(table, string_of_int(i)) } - assert H.isEmpty(table) + assert(H.isEmpty(table)) } module H0 = Belt.HashMap @@ -116,7 +116,7 @@ let bench5 = () => { ) %time( for i in 0 to count { - assert H0.has(table, i) + assert(H0.has(table, i)) } ) %time( @@ -124,7 +124,7 @@ let bench5 = () => { H0.remove(table, i) } ) - assert H0.isEmpty(table) + assert(H0.isEmpty(table)) } module HI = Belt.HashMap.Int @@ -135,7 +135,7 @@ let bench6 = () => { HI.set(table, i, i) } for i in 0 to count { - assert HI.has(table, i) + assert(HI.has(table, i)) } for i in 0 to count { HI.remove(table, i) @@ -157,7 +157,7 @@ let bench7 = () => { /* [%time */ for i in 0 to count { - assert S.has(table, i) + assert(S.has(table, i)) } /* ] */ diff --git a/jscomp/test/bs_queue_test.res b/jscomp/test/bs_queue_test.res index b00befb5db..df132d49b0 100644 --- a/jscomp/test/bs_queue_test.res +++ b/jscomp/test/bs_queue_test.res @@ -22,44 +22,44 @@ let \"++" = (q, x) => { let () = { let q = Q.make() - assert (Q.toArray(q) == [] && Q.size(q) == 0) - assert (Q.toArray(\"++"(q, 1)) == [1] && Q.size(q) == 1) - assert (Q.toArray(\"++"(q, 2)) == [1, 2] && Q.size(q) == 2) - assert (Q.toArray(\"++"(q, 3)) == [1, 2, 3] && Q.size(q) == 3) - assert (Q.toArray(\"++"(q, 4)) == [1, 2, 3, 4] && Q.size(q) == 4) - assert (Q.popExn(q) == 1) - assert (Q.toArray(q) == [2, 3, 4] && Q.size(q) == 3) - assert (Q.popExn(q) == 2) - assert (Q.toArray(q) == [3, 4] && Q.size(q) == 2) - assert (Q.popExn(q) == 3) - assert (Q.toArray(q) == [4] && Q.size(q) == 1) - assert (Q.popExn(q) == 4) - assert (Q.toArray(q) == [] && Q.size(q) == 0) - assert does_raise(Q.popExn, q) + assert(Q.toArray(q) == [] && Q.size(q) == 0) + assert(Q.toArray(\"++"(q, 1)) == [1] && Q.size(q) == 1) + assert(Q.toArray(\"++"(q, 2)) == [1, 2] && Q.size(q) == 2) + assert(Q.toArray(\"++"(q, 3)) == [1, 2, 3] && Q.size(q) == 3) + assert(Q.toArray(\"++"(q, 4)) == [1, 2, 3, 4] && Q.size(q) == 4) + assert(Q.popExn(q) == 1) + assert(Q.toArray(q) == [2, 3, 4] && Q.size(q) == 3) + assert(Q.popExn(q) == 2) + assert(Q.toArray(q) == [3, 4] && Q.size(q) == 2) + assert(Q.popExn(q) == 3) + assert(Q.toArray(q) == [4] && Q.size(q) == 1) + assert(Q.popExn(q) == 4) + assert(Q.toArray(q) == [] && Q.size(q) == 0) + assert(does_raise(Q.popExn, q)) } let () = { let q = Q.make() - assert (Q.popExn(\"++"(q, 1)) == 1) - assert does_raise(Q.popExn, q) - assert (Q.popExn(\"++"(q, 2)) == 2) - assert does_raise(Q.popExn, q) - assert (Q.size(q) == 0) + assert(Q.popExn(\"++"(q, 1)) == 1) + assert(does_raise(Q.popExn, q)) + assert(Q.popExn(\"++"(q, 2)) == 2) + assert(does_raise(Q.popExn, q)) + assert(Q.size(q) == 0) } let () = { let q = Q.make() - assert (Q.peekExn(\"++"(q, 1)) == 1) - assert (Q.peekExn(\"++"(q, 2)) == 1) - assert (Q.peekExn(\"++"(q, 3)) == 1) - assert (Q.peekExn(q) == 1) - assert (Q.popExn(q) == 1) - assert (Q.peekExn(q) == 2) - assert (Q.popExn(q) == 2) - assert (Q.peekExn(q) == 3) - assert (Q.popExn(q) == 3) - assert does_raise(Q.peekExn, q) - assert does_raise(Q.peekExn, q) + assert(Q.peekExn(\"++"(q, 1)) == 1) + assert(Q.peekExn(\"++"(q, 2)) == 1) + assert(Q.peekExn(\"++"(q, 3)) == 1) + assert(Q.peekExn(q) == 1) + assert(Q.popExn(q) == 1) + assert(Q.peekExn(q) == 2) + assert(Q.popExn(q) == 2) + assert(Q.peekExn(q) == 3) + assert(Q.popExn(q) == 3) + assert(does_raise(Q.peekExn, q)) + assert(does_raise(Q.peekExn, q)) } let () = { @@ -68,11 +68,11 @@ let () = { Q.add(q, i) } Q.clear(q) - assert (Q.size(q) == 0) - assert does_raise(Q.popExn, q) - assert (q == Q.make()) + assert(Q.size(q) == 0) + assert(does_raise(Q.popExn, q)) + assert(q == Q.make()) Q.add(q, 42) - assert (Q.popExn(q) == 42) + assert(Q.popExn(q) == 42) } let () = { @@ -81,33 +81,33 @@ let () = { Q.add(q1, i) } let q2 = Q.copy(q1) - assert (Q.toArray(q1) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) - assert (Q.toArray(q2) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) - assert (Q.size(q1) == 10) - assert (Q.size(q2) == 10) + assert(Q.toArray(q1) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) + assert(Q.toArray(q2) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) + assert(Q.size(q1) == 10) + assert(Q.size(q2) == 10) for i in 1 to 10 { - assert (Q.popExn(q1) == i) + assert(Q.popExn(q1) == i) } for i in 1 to 10 { - assert (Q.popExn(q2) == i) + assert(Q.popExn(q2) == i) } } let () = { let q = Q.make() - assert Q.isEmpty(q) + assert(Q.isEmpty(q)) for i in 1 to 10 { Q.add(q, i) - assert (Q.size(q) == i) - assert !Q.isEmpty(q) + assert(Q.size(q) == i) + assert(!Q.isEmpty(q)) } for i in 10 downto 1 { - assert (Q.size(q) == i) - assert !Q.isEmpty(q) + assert(Q.size(q) == i) + assert(!Q.isEmpty(q)) ignore((Q.popExn(q): int)) } - assert (Q.size(q) == 0) - assert Q.isEmpty(q) + assert(Q.size(q) == 0) + assert(Q.isEmpty(q)) } let () = { @@ -117,22 +117,22 @@ let () = { } let i = ref(1) Q.forEach(q, j => { - assert (i.contents == j) + assert(i.contents == j) incr(i) }) } let () = { let q1 = Q.make() and q2 = Q.make() - assert (Q.size(q1) == 0) - assert (Q.toArray(q1) == []) - assert (Q.size(q2) == 0) - assert (Q.toArray(q2) == []) + assert(Q.size(q1) == 0) + assert(Q.toArray(q1) == []) + assert(Q.size(q2) == 0) + assert(Q.toArray(q2) == []) Q.transfer(q1, q2) - assert (Q.size(q1) == 0) - assert (Q.toArray(q1) == []) - assert (Q.size(q2) == 0) - assert (Q.toArray(q2) == []) + assert(Q.size(q1) == 0) + assert(Q.toArray(q1) == []) + assert(Q.size(q2) == 0) + assert(Q.toArray(q2) == []) } let () = { @@ -140,15 +140,15 @@ let () = { for i in 1 to 4 { Q.add(q1, i) } - assert (Q.size(q1) == 4) - assert (Q.toArray(q1) == [1, 2, 3, 4]) - assert (Q.size(q2) == 0) - assert (Q.toArray(q2) == []) + assert(Q.size(q1) == 4) + assert(Q.toArray(q1) == [1, 2, 3, 4]) + assert(Q.size(q2) == 0) + assert(Q.toArray(q2) == []) Q.transfer(q1, q2) - assert (Q.size(q1) == 0) - assert (Q.toArray(q1) == []) - assert (Q.size(q2) == 4) - assert (Q.toArray(q2) == [1, 2, 3, 4]) + assert(Q.size(q1) == 0) + assert(Q.toArray(q1) == []) + assert(Q.size(q2) == 4) + assert(Q.toArray(q2) == [1, 2, 3, 4]) } let () = { @@ -156,15 +156,15 @@ let () = { for i in 5 to 8 { Q.add(q2, i) } - assert (Q.size(q1) == 0) - assert (Q.toArray(q1) == []) - assert (Q.size(q2) == 4) - assert (Q.toArray(q2) == [5, 6, 7, 8]) + assert(Q.size(q1) == 0) + assert(Q.toArray(q1) == []) + assert(Q.size(q2) == 4) + assert(Q.toArray(q2) == [5, 6, 7, 8]) Q.transfer(q1, q2) - assert (Q.size(q1) == 0) - assert (Q.toArray(q1) == []) - assert (Q.size(q2) == 4) - assert (Q.toArray(q2) == [5, 6, 7, 8]) + assert(Q.size(q1) == 0) + assert(Q.toArray(q1) == []) + assert(Q.size(q2) == 4) + assert(Q.toArray(q2) == [5, 6, 7, 8]) } let () = { @@ -175,18 +175,18 @@ let () = { for i in 5 to 8 { Q.add(q2, i) } - assert (Q.size(q1) == 4) - assert (Q.toArray(q1) == [1, 2, 3, 4]) - assert (Q.size(q2) == 4) - assert (Q.toArray(q2) == [5, 6, 7, 8]) + assert(Q.size(q1) == 4) + assert(Q.toArray(q1) == [1, 2, 3, 4]) + assert(Q.size(q2) == 4) + assert(Q.toArray(q2) == [5, 6, 7, 8]) Q.transfer(q1, q2) - assert (Q.size(q1) == 0) - assert (Q.toArray(q1) == []) + assert(Q.size(q1) == 0) + assert(Q.toArray(q1) == []) let v = [5, 6, 7, 8, 1, 2, 3, 4] - assert (Q.size(q2) == 8) - assert (Q.toArray(q2) == v) + assert(Q.size(q2) == 8) + assert(Q.toArray(q2) == v) - assert (Q.reduce(q2, 0, (x, y) => x - y) == Belt.Array.reduce(v, 0, (x, y) => x - y)) + assert(Q.reduce(q2, 0, (x, y) => x - y) == Belt.Array.reduce(v, 0, (x, y) => x - y)) } let () = Js.log("OK") diff --git a/jscomp/test/bs_rbset_int_bench.res b/jscomp/test/bs_rbset_int_bench.res index 7c64fbb6a7..eb1d2a8d2d 100644 --- a/jscomp/test/bs_rbset_int_bench.res +++ b/jscomp/test/bs_rbset_int_bench.res @@ -10,7 +10,7 @@ let bench = () => { ) %time( for i in 0 to count { - assert V.mem(i, data.contents) + assert(V.mem(i, data.contents)) } ) %time( diff --git a/jscomp/test/bs_set_bench.res b/jscomp/test/bs_set_bench.res index a86ddfddbc..118dd79f10 100644 --- a/jscomp/test/bs_set_bench.res +++ b/jscomp/test/bs_set_bench.res @@ -10,7 +10,7 @@ let bench = () => { ) %time( for i in 0 to count { - assert N.has(data.contents, i) + assert(N.has(data.contents, i)) } ) %time( diff --git a/jscomp/test/chn_test.res b/jscomp/test/chn_test.res index 3b6dba7d4e..65dc5666b0 100644 --- a/jscomp/test/chn_test.res +++ b/jscomp/test/chn_test.res @@ -14,7 +14,7 @@ Js.log(`\x3f\u003f\b\t\n\v\f\r\0"'`) let convert = (s: string): list => Js_array2.fromMap(Js_string.castToArrayLike(s), x => switch Js_string2.codePointAt(x, 0) { - | None => assert false + | None => assert(false) | Some(x) => x } ) |> Array.to_list diff --git a/jscomp/test/esmodule_ref.res b/jscomp/test/esmodule_ref.res index 4aebd8f855..4794e81a8a 100644 --- a/jscomp/test/esmodule_ref.res +++ b/jscomp/test/esmodule_ref.res @@ -1,2 +1,2 @@ -assert !Escape_esmodule.__esModule +assert(!Escape_esmodule.__esModule) Js.log(Escape_esmodule.__esModule) diff --git a/jscomp/test/exception_raise_test.res b/jscomp/test/exception_raise_test.res index 5e5384b427..33ed2dac68 100644 --- a/jscomp/test/exception_raise_test.res +++ b/jscomp/test/exception_raise_test.res @@ -101,7 +101,7 @@ let a0 = try %raw(` function (){throw 2} () `) catch { /* throw is a statement */ | A(x) => x | Js.Exn.Error(v) => Obj.magic(v) -| _ => assert false +| _ => assert(false) } let a1: exn = try %raw(` function (){throw 2} () `) catch { @@ -124,7 +124,7 @@ let suites = ref({ _ => switch a1 { | Js.Exn.Error(v) => Eq(Obj.magic(v), 2) - | _ => assert false + | _ => assert(false) }, ), } diff --git a/jscomp/test/ext_list_test.res b/jscomp/test/ext_list_test.res index 4b628ab086..f0abfe1d1f 100644 --- a/jscomp/test/ext_list_test.res +++ b/jscomp/test/ext_list_test.res @@ -469,7 +469,7 @@ let rec assoc_by_string = (def, k: string, lst) => switch lst { | list{} => switch def { - | None => assert false + | None => assert(false) | Some(x) => x } | list{(k1, v1), ...rest} => @@ -484,7 +484,7 @@ let rec assoc_by_int = (def, k: int, lst) => switch lst { | list{} => switch def { - | None => assert false + | None => assert(false) | Some(x) => x } | list{(k1, v1), ...rest} => diff --git a/jscomp/test/extensible_variant_test.res b/jscomp/test/extensible_variant_test.res index 33baeb2924..2dc752116d 100644 --- a/jscomp/test/extensible_variant_test.res +++ b/jscomp/test/extensible_variant_test.res @@ -13,7 +13,7 @@ let to_int = (x: attr) => | Str(_) => -1 | N.Int(a, _) => a | Int(_, b) => b - | _ => assert false + | _ => assert(false) } let suites = { diff --git a/jscomp/test/flexible_array_test.res b/jscomp/test/flexible_array_test.res index 7c692d0b4d..d763132805 100644 --- a/jscomp/test/flexible_array_test.res +++ b/jscomp/test/flexible_array_test.res @@ -77,7 +77,7 @@ let rec lorem = (tr: tree<_>) => | Br(w, Br(v, ll, lr) as l, r) => /* length >= 2 */ Br(v, r, lorem(l)) - | _ => assert false + | _ => assert(false) } module Int_array: { @@ -181,7 +181,7 @@ let \"=~" = (x, y) => Int_array.equal(x, Int_array.of_array(y)) let _ = { let u = Int_array.of_array([1, 2, 2, 5, 3, 6]) - assert \"=~"(Int_array.sort(u), [1, 2, 2, 3, 5, 6]) + assert(\"=~"(Int_array.sort(u), [1, 2, 2, 3, 5, 6])) let len = 500 let v = Array.init(len, i => len - i) \"=~"(Int_array.sort(Int_array.of_array(v)), Array.init(len, i => i + 1)) diff --git a/jscomp/test/format_regression.res b/jscomp/test/format_regression.res index f95e5485d1..52d1cfce89 100644 --- a/jscomp/test/format_regression.res +++ b/jscomp/test/format_regression.res @@ -7,10 +7,10 @@ type queue<'a> = { } type size type pp_token -let peek_queue = _ => assert false -let int_of_size = _ => assert false -let take_queue = _ => assert false -let format_pp_token = (_, _) => assert false +let peek_queue = _ => assert(false) +let int_of_size = _ => assert(false) +let take_queue = _ => assert(false) +let format_pp_token = (_, _) => assert(false) let pp_infinity = 1000000010 type pp_queue_elem = { mutable elem_size: size, diff --git a/jscomp/test/fun_pattern_match.res b/jscomp/test/fun_pattern_match.res index c7e4838f49..8b484e0023 100644 --- a/jscomp/test/fun_pattern_match.res +++ b/jscomp/test/fun_pattern_match.res @@ -30,13 +30,13 @@ let f3 = ({rank: lhs, _}, {rank: rhs}) => /* generate curried version when pattern match against arguments */ switch (lhs, rhs) { | (Ranked(x), Ranked(y)) => Pervasives.compare(x, y) - | _ => assert false + | _ => assert(false) } let f4 = ({rank: lhs, _}, {rank: rhs}) => switch (lhs, rhs) { | (Ranked(x), Ranked(y)) => Pervasives.compare(x, y) - | _ => assert false + | _ => assert(false) } /* #995 test case */ diff --git a/jscomp/test/gpr_1150.res b/jscomp/test/gpr_1150.res index 8557436884..9c33473f37 100644 --- a/jscomp/test/gpr_1150.res +++ b/jscomp/test/gpr_1150.res @@ -97,7 +97,7 @@ let f = children => a14, a15, ] - | list{a16, ...children} => assert false + | list{a16, ...children} => assert(false) } } } diff --git a/jscomp/test/gpr_1698_test.res b/jscomp/test/gpr_1698_test.res index b06d10bb93..0cfd35ad6b 100644 --- a/jscomp/test/gpr_1698_test.res +++ b/jscomp/test/gpr_1698_test.res @@ -38,7 +38,7 @@ let rec compare = (context, state, a, b) => | (_, Sum(_), _) => 1 | (Gcd(_), _, _) => 1 | (_, Gcd(_), _) => -1 - | _ => assert false + | _ => assert(false) } let a = Sum(list{sym("a"), Val(Natural(2))}) let b = sym("x") diff --git a/jscomp/test/gpr_2682_test.res b/jscomp/test/gpr_2682_test.res index e20732502a..638604b79c 100644 --- a/jscomp/test/gpr_2682_test.res +++ b/jscomp/test/gpr_2682_test.res @@ -49,4 +49,4 @@ let f3: (. unit) => bool = %raw("()=>true") let bbbb = f3(.) -assert bbbb +assert(bbbb) diff --git a/jscomp/test/gpr_3980_test.res b/jscomp/test/gpr_3980_test.res index 80d235ba32..0e2e4b7c90 100644 --- a/jscomp/test/gpr_3980_test.res +++ b/jscomp/test/gpr_3980_test.res @@ -10,7 +10,7 @@ let _ = switch Some(1) { name: "bye", age: Js.Math.floor(1.), } - | _ => assert false + | _ => assert(false) } -| _ => assert false +| _ => assert(false) } diff --git a/jscomp/test/gpr_405_test.res b/jscomp/test/gpr_405_test.res index f45bcd5e9c..bdb3867636 100644 --- a/jscomp/test/gpr_405_test.res +++ b/jscomp/test/gpr_405_test.res @@ -37,8 +37,8 @@ module Make = (G: G) => { let counter = ref(1) let rec step2 = (top, rest_of_stack) => { - assert !is_already_processed(top) - assert !is_on_the_stack(top) + assert(!is_already_processed(top)) + assert(!is_on_the_stack(top)) H.add(on_the_stack, top, true) H.add(n_labels, top, counter.contents) counter := counter.contents + 1 diff --git a/jscomp/test/inline_map2_test.res b/jscomp/test/inline_map2_test.res index 6d12c22e0f..b9e0dcda19 100644 --- a/jscomp/test/inline_map2_test.res +++ b/jscomp/test/inline_map2_test.res @@ -356,7 +356,7 @@ module Make = (Ord: OrderedType) => { | (_, Node(l2, v2, d2, r2, h2)) => let (l1, d1, r1) = split(v2, s1) concat_or_join(merge(f, l1, l2), v2, f(v2, d1, Some(d2)), merge(f, r1, r2)) - | _ => assert false + | _ => assert(false) } let rec filter = (p, x) => diff --git a/jscomp/test/inline_map_demo.res b/jscomp/test/inline_map_demo.res index 9182da7042..34ee7b3763 100644 --- a/jscomp/test/inline_map_demo.res +++ b/jscomp/test/inline_map_demo.res @@ -38,13 +38,13 @@ let bal = (l, x, d, r) => { } if hl > hr + 2 { switch l { - | Empty => assert false + | Empty => assert(false) | Node(ll, lv, ld, lr, _) => if height(ll) >= height(lr) { create(ll, lv, ld, create(lr, x, d, r)) } else { switch lr { - | Empty => assert false + | Empty => assert(false) | Node(lrl, lrv, lrd, lrr, _) => create(create(ll, lv, ld, lrl), lrv, lrd, create(lrr, x, d, r)) } @@ -52,13 +52,13 @@ let bal = (l, x, d, r) => { } } else if hr > hl + 2 { switch r { - | Empty => assert false + | Empty => assert(false) | Node(rl, rv, rd, rr, _) => if height(rr) >= height(rl) { create(create(l, x, d, rl), rv, rd, rr) } else { switch rl { - | Empty => assert false + | Empty => assert(false) | Node(rll, rlv, rld, rlr, _) => create(create(l, x, d, rll), rlv, rld, create(rlr, rv, rd, rr)) } diff --git a/jscomp/test/inline_map_test.res b/jscomp/test/inline_map_test.res index fb0c87fbb8..01368d7500 100644 --- a/jscomp/test/inline_map_test.res +++ b/jscomp/test/inline_map_test.res @@ -314,7 +314,7 @@ let rec merge = (f, s1, s2) => | (_, Node(l2, v2, d2, r2, h2)) => let (l1, d1, r1) = split(v2, s1) concat_or_join(merge(f, l1, l2), v2, f(v2, d1, Some(d2)), merge(f, r1, r2)) - | _ => assert false + | _ => assert(false) } let rec filter = (p, x) => diff --git a/jscomp/test/inline_record_test.res b/jscomp/test/inline_record_test.res index 2cccf353a7..cabfb7dd85 100644 --- a/jscomp/test/inline_record_test.res +++ b/jscomp/test/inline_record_test.res @@ -44,7 +44,7 @@ eq( __LOC__, switch v3 { | A0({lbl}) => lbl - | _ => assert false + | _ => assert(false) }, 3, ) @@ -71,7 +71,7 @@ eq( __LOC__, switch v4 { | A0(u) => u.x - | _ => assert false + | _ => assert(false) }, 11, ) @@ -80,7 +80,7 @@ eq( __LOC__, switch v5 { | A1(u) => u.z - | _ => assert false + | _ => assert(false) }, 22, ) @@ -105,7 +105,7 @@ eq( __LOC__, switch v6 { | A4(u) => u.x - | _ => assert false + | _ => assert(false) }, 11, ) diff --git a/jscomp/test/int64_string_test.res b/jscomp/test/int64_string_test.res index b7acd912a3..804eb3bfcb 100644 --- a/jscomp/test/int64_string_test.res +++ b/jscomp/test/int64_string_test.res @@ -188,7 +188,7 @@ let random_data = list{ Belt_List.forEach(random_data, u => switch u { | list{(v, str)} => eq(__LOC__, Int64.to_string(v), str) - | _ => assert false + | _ => assert(false) } ) diff --git a/jscomp/test/js_json_test.res b/jscomp/test/js_json_test.res index 6675d68e5b..d76d268d3c 100644 --- a/jscomp/test/js_json_test.res +++ b/jscomp/test/js_json_test.res @@ -34,7 +34,7 @@ let () = { let ty3 = J.classify(x) switch ty3 { | J.JSONNumber(_) => () - | _ => assert false + | _ => assert(false) } }) |> (() => Mt.Ok(true)) | _ => Mt.Ok(false) @@ -108,7 +108,7 @@ let () = { let option_get = x => switch x { - | None => assert false + | None => assert(false) | Some(x) => x } diff --git a/jscomp/test/libqueue_test.res b/jscomp/test/libqueue_test.res index 853024a3e1..d5a33beb89 100644 --- a/jscomp/test/libqueue_test.res +++ b/jscomp/test/libqueue_test.res @@ -27,53 +27,53 @@ let does_raise = (f, q) => let () = { let q = Q.create() () - assert (Q.to_list(q) == list{} && Q.length(q) == 0) + assert(Q.to_list(q) == list{} && Q.length(q) == 0) Q.add(1, q) - assert (Q.to_list(q) == list{1} && Q.length(q) == 1) + assert(Q.to_list(q) == list{1} && Q.length(q) == 1) Q.add(2, q) - assert (Q.to_list(q) == list{1, 2} && Q.length(q) == 2) + assert(Q.to_list(q) == list{1, 2} && Q.length(q) == 2) Q.add(3, q) - assert (Q.to_list(q) == list{1, 2, 3} && Q.length(q) == 3) + assert(Q.to_list(q) == list{1, 2, 3} && Q.length(q) == 3) Q.add(4, q) - assert (Q.to_list(q) == list{1, 2, 3, 4} && Q.length(q) == 4) - assert (Q.take(q) == 1) - assert (Q.to_list(q) == list{2, 3, 4} && Q.length(q) == 3) - assert (Q.take(q) == 2) - assert (Q.to_list(q) == list{3, 4} && Q.length(q) == 2) - assert (Q.take(q) == 3) - assert (Q.to_list(q) == list{4} && Q.length(q) == 1) - assert (Q.take(q) == 4) - assert (Q.to_list(q) == list{} && Q.length(q) == 0) - assert does_raise(Q.take, q) + assert(Q.to_list(q) == list{1, 2, 3, 4} && Q.length(q) == 4) + assert(Q.take(q) == 1) + assert(Q.to_list(q) == list{2, 3, 4} && Q.length(q) == 3) + assert(Q.take(q) == 2) + assert(Q.to_list(q) == list{3, 4} && Q.length(q) == 2) + assert(Q.take(q) == 3) + assert(Q.to_list(q) == list{4} && Q.length(q) == 1) + assert(Q.take(q) == 4) + assert(Q.to_list(q) == list{} && Q.length(q) == 0) + assert(does_raise(Q.take, q)) } let () = { let q = Q.create() Q.add(1, q) - assert (Q.take(q) == 1) - assert does_raise(Q.take, q) + assert(Q.take(q) == 1) + assert(does_raise(Q.take, q)) Q.add(2, q) - assert (Q.take(q) == 2) - assert does_raise(Q.take, q) - assert (Q.length(q) == 0) + assert(Q.take(q) == 2) + assert(does_raise(Q.take, q)) + assert(Q.length(q) == 0) } let () = { let q = Q.create() Q.add(1, q) - assert (Q.peek(q) == 1) + assert(Q.peek(q) == 1) Q.add(2, q) - assert (Q.peek(q) == 1) + assert(Q.peek(q) == 1) Q.add(3, q) - assert (Q.peek(q) == 1) - assert (Q.peek(q) == 1) - assert (Q.take(q) == 1) - assert (Q.peek(q) == 2) - assert (Q.take(q) == 2) - assert (Q.peek(q) == 3) - assert (Q.take(q) == 3) - assert does_raise(Q.peek, q) - assert does_raise(Q.peek, q) + assert(Q.peek(q) == 1) + assert(Q.peek(q) == 1) + assert(Q.take(q) == 1) + assert(Q.peek(q) == 2) + assert(Q.take(q) == 2) + assert(Q.peek(q) == 3) + assert(Q.take(q) == 3) + assert(does_raise(Q.peek, q)) + assert(does_raise(Q.peek, q)) } let () = { @@ -82,11 +82,11 @@ let () = { Q.add(i, q) } Q.clear(q) - assert (Q.length(q) == 0) - assert does_raise(Q.take, q) - assert (q == Q.create()) + assert(Q.length(q) == 0) + assert(does_raise(Q.take, q)) + assert(q == Q.create()) Q.add(42, q) - assert (Q.take(q) == 42) + assert(Q.take(q) == 42) } let () = { @@ -95,33 +95,33 @@ let () = { Q.add(i, q1) } let q2 = Q.copy(q1) - assert (Q.to_list(q1) == list{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) - assert (Q.to_list(q2) == list{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) - assert (Q.length(q1) == 10) - assert (Q.length(q2) == 10) + assert(Q.to_list(q1) == list{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) + assert(Q.to_list(q2) == list{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) + assert(Q.length(q1) == 10) + assert(Q.length(q2) == 10) for i in 1 to 10 { - assert (Q.take(q1) == i) + assert(Q.take(q1) == i) } for i in 1 to 10 { - assert (Q.take(q2) == i) + assert(Q.take(q2) == i) } } let () = { let q = Q.create() - assert Q.is_empty(q) + assert(Q.is_empty(q)) for i in 1 to 10 { Q.add(i, q) - assert (Q.length(q) == i) - assert !Q.is_empty(q) + assert(Q.length(q) == i) + assert(!Q.is_empty(q)) } for i in 10 downto 1 { - assert (Q.length(q) == i) - assert !Q.is_empty(q) + assert(Q.length(q) == i) + assert(!Q.is_empty(q)) ignore((Q.take(q): int)) } - assert (Q.length(q) == 0) - assert Q.is_empty(q) + assert(Q.length(q) == 0) + assert(Q.is_empty(q)) } let () = { @@ -131,22 +131,22 @@ let () = { } let i = ref(1) Q.iter(j => { - assert (i.contents == j) + assert(i.contents == j) incr(i) }, q) } let () = { let q1 = Q.create() and q2 = Q.create() - assert (Q.length(q1) == 0) - assert (Q.to_list(q1) == list{}) - assert (Q.length(q2) == 0) - assert (Q.to_list(q2) == list{}) + assert(Q.length(q1) == 0) + assert(Q.to_list(q1) == list{}) + assert(Q.length(q2) == 0) + assert(Q.to_list(q2) == list{}) Q.transfer(q1, q2) - assert (Q.length(q1) == 0) - assert (Q.to_list(q1) == list{}) - assert (Q.length(q2) == 0) - assert (Q.to_list(q2) == list{}) + assert(Q.length(q1) == 0) + assert(Q.to_list(q1) == list{}) + assert(Q.length(q2) == 0) + assert(Q.to_list(q2) == list{}) } let () = { @@ -154,15 +154,15 @@ let () = { for i in 1 to 4 { Q.add(i, q1) } - assert (Q.length(q1) == 4) - assert (Q.to_list(q1) == list{1, 2, 3, 4}) - assert (Q.length(q2) == 0) - assert (Q.to_list(q2) == list{}) + assert(Q.length(q1) == 4) + assert(Q.to_list(q1) == list{1, 2, 3, 4}) + assert(Q.length(q2) == 0) + assert(Q.to_list(q2) == list{}) Q.transfer(q1, q2) - assert (Q.length(q1) == 0) - assert (Q.to_list(q1) == list{}) - assert (Q.length(q2) == 4) - assert (Q.to_list(q2) == list{1, 2, 3, 4}) + assert(Q.length(q1) == 0) + assert(Q.to_list(q1) == list{}) + assert(Q.length(q2) == 4) + assert(Q.to_list(q2) == list{1, 2, 3, 4}) } let () = { @@ -170,15 +170,15 @@ let () = { for i in 5 to 8 { Q.add(i, q2) } - assert (Q.length(q1) == 0) - assert (Q.to_list(q1) == list{}) - assert (Q.length(q2) == 4) - assert (Q.to_list(q2) == list{5, 6, 7, 8}) + assert(Q.length(q1) == 0) + assert(Q.to_list(q1) == list{}) + assert(Q.length(q2) == 4) + assert(Q.to_list(q2) == list{5, 6, 7, 8}) Q.transfer(q1, q2) - assert (Q.length(q1) == 0) - assert (Q.to_list(q1) == list{}) - assert (Q.length(q2) == 4) - assert (Q.to_list(q2) == list{5, 6, 7, 8}) + assert(Q.length(q1) == 0) + assert(Q.to_list(q1) == list{}) + assert(Q.length(q2) == 4) + assert(Q.to_list(q2) == list{5, 6, 7, 8}) } let () = { @@ -189,15 +189,15 @@ let () = { for i in 5 to 8 { Q.add(i, q2) } - assert (Q.length(q1) == 4) - assert (Q.to_list(q1) == list{1, 2, 3, 4}) - assert (Q.length(q2) == 4) - assert (Q.to_list(q2) == list{5, 6, 7, 8}) + assert(Q.length(q1) == 4) + assert(Q.to_list(q1) == list{1, 2, 3, 4}) + assert(Q.length(q2) == 4) + assert(Q.to_list(q2) == list{5, 6, 7, 8}) Q.transfer(q1, q2) - assert (Q.length(q1) == 0) - assert (Q.to_list(q1) == list{}) - assert (Q.length(q2) == 8) - assert (Q.to_list(q2) == list{5, 6, 7, 8, 1, 2, 3, 4}) + assert(Q.length(q1) == 0) + assert(Q.to_list(q1) == list{}) + assert(Q.length(q2) == 8) + assert(Q.to_list(q2) == list{5, 6, 7, 8, 1, 2, 3, 4}) } let () = print_endline("OK") diff --git a/jscomp/test/noassert.res b/jscomp/test/noassert.res index 432a9024e6..fcc6aa74da 100644 --- a/jscomp/test/noassert.res +++ b/jscomp/test/noassert.res @@ -1,3 +1,3 @@ -let f = () => assert false +let f = () => assert (false) let h = () => assert (3 > 2) diff --git a/jscomp/test/ocaml_re_test.res b/jscomp/test/ocaml_re_test.res index 983e74c061..d4b40171c6 100644 --- a/jscomp/test/ocaml_re_test.res +++ b/jscomp/test/ocaml_re_test.res @@ -253,7 +253,7 @@ module Re_cset: { } else { list{(list{(d, c - 1)}, x'), ...prepend(s, x, list{(list{(c, d')}, x'), ...r'})} } - | _ => assert false + | _ => assert(false) } let pick = x => @@ -813,7 +813,7 @@ module Re_automata: { let rec split_at_match_rec = (l', x) => switch x { - | list{} => assert false + | list{} => assert(false) | list{E.TMatch(_), ...r} => (List.rev(l'), remove_matches(r)) | list{x, ...r} => split_at_match_rec(list{x, ...l'}, r) } @@ -2166,7 +2166,7 @@ let rec loop info s pos st = | Intersection(_) | Complement(_) | Difference(_) => - assert false + assert(false) } colorize(regexp) @@ -2400,7 +2400,7 @@ let rec loop info s pos st = } else { (A.seq(ids, #First, A.erase(ids, b, e), cr), kind') } - | Difference(_) | Complement(_) | Intersection(_) | No_case(_) | Case(_) => assert false + | Difference(_) | Complement(_) | Intersection(_) | No_case(_) | Case(_) => assert(false) | Pmark(i, r') => let (cr, kind') = translate(ids, kind, ign_group, ign_case, greedy, pos, cache, c, r') (A.seq(ids, #First, A.pmark(ids, i), cr), kind') @@ -2435,7 +2435,7 @@ let rec loop info s pos st = let as_set = x => switch x { | Set(s) => s - | _ => assert false + | _ => assert(false) } /* XXX Should split alternatives into (1) charsets and (2) more @@ -3108,7 +3108,7 @@ let rec loop info s pos st = | Set(c) => String.make(1, Char.chr(Cset.pick(c))) | Sequence(xs) => String.concat("", List.map(witness, xs)) | Alternative(list{x, ..._}) => witness(x) - | Alternative(list{}) => assert false + | Alternative(list{}) => assert(false) | Repeat(r, from, _to) => let w = witness(r) let b = Buffer.create(String.length(w) * from) @@ -3120,7 +3120,7 @@ let rec loop info s pos st = | Intersection(_) | Complement(_) | Difference(_, _) => - assert false + assert(false) | Group(r) | No_group(r) | Nest(r) diff --git a/jscomp/test/raw_hash_tbl_bench.res b/jscomp/test/raw_hash_tbl_bench.res index dc64004857..0e19e2e2c4 100644 --- a/jscomp/test/raw_hash_tbl_bench.res +++ b/jscomp/test/raw_hash_tbl_bench.res @@ -5,7 +5,7 @@ let bench = () => { Hashtbl.add(table, i, i) } for i in 0 to count { - assert Hashtbl.mem(table, i) + assert(Hashtbl.mem(table, i)) } for i in 0 to count { Hashtbl.remove(table, i) diff --git a/jscomp/test/rbset.res b/jscomp/test/rbset.res index 9de160a0b4..75b803920d 100644 --- a/jscomp/test/rbset.res +++ b/jscomp/test/rbset.res @@ -61,7 +61,7 @@ let unbalanced_left = x => Node(Black, a, x, balance_left(Node(Red, b, y, c), z, d)), false, ) - | _ => assert false + | _ => assert(false) } let unbalanced_right = x => @@ -72,7 +72,7 @@ let unbalanced_right = x => Node(Black, balance_right(a, x, Node(Red, b, y, c)), z, d), false, ) - | _ => assert false + | _ => assert(false) } let lbalance = (x1, x2, x3) => @@ -135,7 +135,7 @@ let rec remove_min = x => switch x { | Empty | Node(Black, Empty, _, Node(Black, _, _, _)) => - assert false + assert(false) | Node(Black, Empty, x, Empty) => (Empty, x, true) | Node(Black, Empty, x, Node(Red, l, y, r)) => (Node(Black, l, y, r), x, false) | Node(Red, Empty, x, r) => (r, x, false) diff --git a/jscomp/test/recursive_records_test.res b/jscomp/test/recursive_records_test.res index b08800b388..e98f5cc7e9 100644 --- a/jscomp/test/recursive_records_test.res +++ b/jscomp/test/recursive_records_test.res @@ -46,7 +46,7 @@ let hd = x => let tl_exn = x => switch x { - | Nil => assert false + | Nil => assert(false) | Cons(x) => x.next } diff --git a/jscomp/test/return_check.res b/jscomp/test/return_check.res index 9fa6d2825e..8492cba278 100644 --- a/jscomp/test/return_check.res +++ b/jscomp/test/return_check.res @@ -20,7 +20,7 @@ let test = dom => { let f_undefined = (xs, i) => switch get_undefined(xs, i) { - | None => assert false + | None => assert(false) | Some(k) => k } @@ -48,7 +48,7 @@ let f_escaped_2 = (xs, i) => Js.log(get_undefined(xs, i)) let f_null = (xs, i) => switch get_null(xs, i) { - | None => assert false + | None => assert(false) | Some(k) => k } @@ -56,6 +56,6 @@ let f_null = (xs, i) => let f_null_undefined = (xs, i) => switch get_null_undefined(xs, i) { - | None => assert false + | None => assert(false) | Some(k) => k } diff --git a/jscomp/test/set_gen.res b/jscomp/test/set_gen.res index 370456be3e..eee26c1da5 100644 --- a/jscomp/test/set_gen.res +++ b/jscomp/test/set_gen.res @@ -275,7 +275,7 @@ let internal_bal = (l, v, r) => { } if hl > hr + 2 { switch l { - | Empty => assert false + | Empty => assert(false) | Node(ll, lv, lr, _) => if height(ll) >= height(lr) { /* [ll] >~ [lr] @@ -285,7 +285,7 @@ let internal_bal = (l, v, r) => { create(ll, lv, create(lr, v, r)) } else { switch lr { - | Empty => assert false + | Empty => assert(false) | Node(lrl, lrv, lrr, _) => /* [lr] >~ [ll] [lr] >~ [r] @@ -297,13 +297,13 @@ let internal_bal = (l, v, r) => { } } else if hr > hl + 2 { switch r { - | Empty => assert false + | Empty => assert(false) | Node(rl, rv, rr, _) => if height(rr) >= height(rl) { create(create(l, v, rl), rv, rr) } else { switch rl { - | Empty => assert false + | Empty => assert(false) | Node(rll, rlv, rlr, _) => create(create(l, v, rll), rlv, create(rlr, rv, rr)) } } @@ -444,7 +444,7 @@ let of_sorted_list = l => { let nl = n / 2 let (left, l) = sub(nl, l) switch l { - | list{} => assert false + | list{} => assert(false) | list{mid, ...l} => let (right, l) = sub(n - nl - 1, l) (create(left, mid, right), l) diff --git a/jscomp/test/sexpm.res b/jscomp/test/sexpm.res index 3829aa407c..d392590b27 100644 --- a/jscomp/test/sexpm.res +++ b/jscomp/test/sexpm.res @@ -149,7 +149,7 @@ module MakeDecode = (M: MONAD) => { and expr_starting_with = (c, k, t) => switch c { - | ' ' | '\t' | '\n' => assert false + | ' ' | '\t' | '\n' => assert(false) | ';' => skip_comment((_, ()) => expr(k, t), t) | '(' => expr_list(list{}, k, t) | ')' => _error(t, "unexpected ')'") diff --git a/jscomp/test/stringmatch_test.res b/jscomp/test/stringmatch_test.res index fb9c5cdbb5..eb57d1875e 100644 --- a/jscomp/test/stringmatch_test.res +++ b/jscomp/test/stringmatch_test.res @@ -30,9 +30,9 @@ let () = { let tst02 = s => { let len = String.length(s) switch s { - | "" if len < 0 => assert false + | "" if len < 0 => assert(false) | "" => 1 - | _ if len == 0 => assert false + | _ if len == 0 => assert(false) | "A" => 2 | _ => 3 } diff --git a/jscomp/test/test_bool_equal.res b/jscomp/test/test_bool_equal.res index bcd9614d16..304644a39a 100644 --- a/jscomp/test/test_bool_equal.res +++ b/jscomp/test/test_bool_equal.res @@ -13,14 +13,14 @@ let bool_equal = (x, y) => which return the same value whether user input [true] or [false] u.bool_equal(false,true) */ let assertions = () => { - assert bool_equal(true, true) - assert bool_equal(false, false) - assert !bool_equal(true, false) - assert !bool_equal(false, true) - assert (true == true) - assert (false == false) - assert !(true == false) - assert !(false == true) + assert(bool_equal(true, true)) + assert(bool_equal(false, false)) + assert(!bool_equal(true, false)) + assert(!bool_equal(false, true)) + assert(true == true) + assert(false == false) + assert(!(true == false)) + assert(!(false == true)) } let f0 = x => diff --git a/jscomp/test/test_list.res b/jscomp/test/test_list.res index 0db3aa21db..050cccb89a 100644 --- a/jscomp/test/test_list.res +++ b/jscomp/test/test_list.res @@ -340,7 +340,7 @@ let rec chop = (k, l) => } else { switch l { | list{x, ...t} => chop(k - 1, t) - | _ => assert false + | _ => assert(false) } } diff --git a/jscomp/test/test_set.res b/jscomp/test/test_set.res index 37404076d5..5d95e32f64 100644 --- a/jscomp/test/test_set.res +++ b/jscomp/test/test_set.res @@ -494,7 +494,7 @@ module Make = (Ord: OrderedType) => { let nl = n / 2 let (left, l) = sub(nl, l) switch l { - | list{} => assert false + | list{} => assert(false) | list{mid, ...l} => let (right, l) = sub(n - nl - 1, l) (create(left, mid, right), l) diff --git a/jscomp/test/test_string.res b/jscomp/test/test_string.res index 02d35cb3d4..bf06d03e99 100644 --- a/jscomp/test/test_string.res +++ b/jscomp/test/test_string.res @@ -2,7 +2,7 @@ let f = x => switch x { | "aaaabb" => 0 | "bbbb" => 1 - | _ => /* 2 */ assert false + | _ => /* 2 */ assert(false) } let a = x => "hello" ++ ("world" ++ ("hello" ++ x)) diff --git a/jscomp/test/test_string_case.res b/jscomp/test/test_string_case.res index 051a9a81f9..8003b11892 100644 --- a/jscomp/test/test_string_case.res +++ b/jscomp/test/test_string_case.res @@ -2,7 +2,7 @@ let f = x => switch x { | "abcd" => 0 | "bcde" => 1 - | _ => assert false + | _ => assert(false) } /* local variables: */ diff --git a/jscomp/test/test_trywith.res b/jscomp/test/test_trywith.res index 6c8a0c682a..cc28560e6c 100644 --- a/jscomp/test/test_trywith.res +++ b/jscomp/test/test_trywith.res @@ -56,5 +56,5 @@ let f = (x: u) => | B | C => 2 - | _ => assert false + | _ => assert(false) } diff --git a/jscomp/test/topsort_test.res b/jscomp/test/topsort_test.res index 19ba60d5b9..102d571d7b 100644 --- a/jscomp/test/topsort_test.res +++ b/jscomp/test/topsort_test.res @@ -145,8 +145,8 @@ let () = assert (pathsort(grwork) == list{"wake", "shower", "dress", "eat", "was let () = try { \"@@"(ignore, pathsort(list{("go", "eat"), ...grwork})) - assert false + assert(false) } catch { | Cycle(list{"go", "washup", "eat", "go"}) => () -| _ => assert false +| _ => assert(false) } diff --git a/res_syntax/src/res_core.ml b/res_syntax/src/res_core.ml index cebb6805dc..d1c9c850dc 100644 --- a/res_syntax/src/res_core.ml +++ b/res_syntax/src/res_core.ml @@ -2110,7 +2110,7 @@ and parseOperandExpr ~context p = match p.Parser.token with | Assert -> Parser.next p; - let expr = parseUnaryExpr p in + let expr = parseExpr p in let loc = mkLoc startPos p.prevEndPos in Ast_helper.Exp.assert_ ~loc expr | Lident "async" diff --git a/res_syntax/src/res_printer.ml b/res_syntax/src/res_printer.ml index 476463200e..b3772194d9 100644 --- a/res_syntax/src/res_printer.ml +++ b/res_syntax/src/res_printer.ml @@ -3187,14 +3187,8 @@ and printExpression ~state (e : Parsetree.expression) cmtTbl = | Pexp_letexception (_extensionConstructor, _expr) -> printExpressionBlock ~state ~braces:true e cmtTbl | Pexp_assert expr -> - let rhs = - let doc = printExpressionWithComments ~state expr cmtTbl in - match Parens.lazyOrAssertOrAwaitExprRhs expr with - | Parens.Parenthesized -> addParens doc - | Braced braces -> printBraces doc expr braces - | Nothing -> doc - in - Doc.concat [Doc.text "assert "; rhs] + let expr = printExpressionWithComments ~state expr cmtTbl in + Doc.concat [Doc.text "assert("; expr; Doc.text ")"] | Pexp_lazy expr -> let rhs = let doc = printExpressionWithComments ~state expr cmtTbl in diff --git a/res_syntax/tests/idempotency/genType/src/Arnold.res b/res_syntax/tests/idempotency/genType/src/Arnold.res index 22b5eaf226..a6df0375b0 100644 --- a/res_syntax/tests/idempotency/genType/src/Arnold.res +++ b/res_syntax/tests/idempotency/genType/src/Arnold.res @@ -364,7 +364,7 @@ module State = { let sequence = states => switch states { - | list{} => assert false + | list{} => assert(false) | list{s, ...nextStates} => List.fold_left(seq, s, nextStates) } @@ -382,7 +382,7 @@ module State = { let nondet = states => switch states { - | list{} => assert false + | list{} => assert(false) | list{s, ...nextStates} => List.fold_left(nd, s, nextStates) } @@ -530,14 +530,14 @@ module FunctionTable = { let getFunctionDefinition = (~functionName, tbl: t) => try Hashtbl.find(tbl, functionName) catch { - | Not_found => assert false + | Not_found => assert(false) } let isInFunctionInTable = (~functionTable, path) => Hashtbl.mem(functionTable, Path.name(path)) let addFunction = (~functionName, tbl: t) => { if Hashtbl.mem(tbl, functionName) { - assert false + assert(false) } Hashtbl.replace(tbl, functionName, initialFunctionDefinition()) } @@ -870,7 +870,7 @@ module Compile = { | Some(_kind) => // TODO when kinds are extended in future: check that args matches with kind // and create a function call with the appropriate arguments - assert false + assert(false) | None => expr |> expression(~ctx) |> evalArgs(~args, ~ctx) } } @@ -945,7 +945,7 @@ module Compile = { \"+++"(cE, nondet(cCases)) } - | Texp_match(_, _, list{_, ..._} as _casesExn, _) => assert false + | Texp_match(_, _, list{_, ..._} as _casesExn, _) => assert(false) | Texp_field(e, _lid, _desc) => e |> expression(~ctx) @@ -972,23 +972,23 @@ module Compile = { | Texp_assert(_) => Command.nothing - | Texp_try(_) => assert false - | Texp_variant(_) => assert false - | Texp_array(_) => assert false - | Texp_while(_) => assert false - | Texp_for(_) => assert false - | Texp_send(_) => assert false - | Texp_new(_) => assert false - | Texp_instvar(_) => assert false - | Texp_setinstvar(_) => assert false - | Texp_override(_) => assert false - | Texp_letmodule(_) => assert false - | Texp_letexception(_) => assert false - | Texp_lazy(_) => assert false - | Texp_object(_) => assert false - | Texp_pack(_) => assert false - | Texp_unreachable => assert false - | Texp_extension_constructor(_) => assert false + | Texp_try(_) => assert(false) + | Texp_variant(_) => assert(false) + | Texp_array(_) => assert(false) + | Texp_while(_) => assert(false) + | Texp_for(_) => assert(false) + | Texp_send(_) => assert(false) + | Texp_new(_) => assert(false) + | Texp_instvar(_) => assert(false) + | Texp_setinstvar(_) => assert(false) + | Texp_override(_) => assert(false) + | Texp_letmodule(_) => assert(false) + | Texp_letexception(_) => assert(false) + | Texp_lazy(_) => assert(false) + | Texp_object(_) => assert(false) + | Texp_pack(_) => assert(false) + | Texp_unreachable => assert(false) + | Texp_extension_constructor(_) => assert(false) } } and expressionOpt = (~ctx, eOpt) => @@ -1144,7 +1144,7 @@ module Eval = { callStack |> CallStack.addFunctionCall(~functionCall, ~pos) let body = switch functionDefinition.body { | Some(body) => body - | None => assert false + | None => assert(false) } let stateAfterCall = body |> run( @@ -1305,7 +1305,7 @@ module Eval = { } else { let body = switch functionDefinition.body { | Some(body) => body - | None => assert false + | None => assert(false) } let state = body |> run( @@ -1340,7 +1340,7 @@ let progressFunctionsFromAttributes = attributes => { |> List.map(x => switch x { | Annotation.IdentPayload(lid) => lidToString(lid) - | _ => assert false + | _ => assert(false) } ) | _ => list{} diff --git a/res_syntax/tests/idempotency/genType/src/ExportModule.res b/res_syntax/tests/idempotency/genType/src/ExportModule.res index 4d4913ce01..44af002a43 100644 --- a/res_syntax/tests/idempotency/genType/src/ExportModule.res +++ b/res_syntax/tests/idempotency/genType/src/ExportModule.res @@ -43,7 +43,7 @@ let rec extendExportModuleItem = (x, ~exportModuleItem: exportModuleItem, ~type_ | list{fieldName, ...rest} => let innerExportModuleItem = switch Hashtbl.find(exportModuleItem, fieldName) { | M(innerExportModuleItem) => innerExportModuleItem - | S(_) => assert false + | S(_) => assert(false) | exception Not_found => let innerExportModuleItem = Hashtbl.create(1) Hashtbl.replace(exportModuleItem, fieldName, M(innerExportModuleItem)) @@ -54,7 +54,7 @@ let rec extendExportModuleItem = (x, ~exportModuleItem: exportModuleItem, ~type_ let extendExportModuleItems = (x, ~exportModuleItems: exportModuleItems, ~type_, ~valueName) => switch x { - | list{} => assert false + | list{} => assert(false) | list{_valueName} => () | list{moduleName, ...rest} => let exportModuleItem = switch Hashtbl.find(exportModuleItems, moduleName) { diff --git a/res_syntax/tests/idempotency/genType/src/GenType.res b/res_syntax/tests/idempotency/genType/src/GenType.res index 24b4c3dfe4..ecf84275bf 100644 --- a/res_syntax/tests/idempotency/genType/src/GenType.res +++ b/res_syntax/tests/idempotency/genType/src/GenType.res @@ -70,7 +70,7 @@ let cli = () => { | list{cmt, ...rest} => let mlast = rest |> String.concat("") (cmt, mlast) - | _ => assert false + | _ => assert(false) } let config = Paths.readConfig(~bsVersion, ~namespace=cmt |> Paths.findNameSpace) if Debug.basic.contents { diff --git a/res_syntax/tests/idempotency/genType/src/GenTypeMain.res b/res_syntax/tests/idempotency/genType/src/GenTypeMain.res index c7639120fc..4c2c61ad24 100644 --- a/res_syntax/tests/idempotency/genType/src/GenTypeMain.res +++ b/res_syntax/tests/idempotency/genType/src/GenTypeMain.res @@ -127,7 +127,7 @@ let readCmt = cmtFile => ) Log_.item("Check that bs-platform is version 6.2.x or later.\n") Log_.item("And try to clean and rebuild.\n\n") - assert false + assert(false) } let processCmtFile = (~signFile, ~config, cmt) => { diff --git a/res_syntax/tests/idempotency/genType/src/Paths.res b/res_syntax/tests/idempotency/genType/src/Paths.res index 89337e464f..259cac501e 100644 --- a/res_syntax/tests/idempotency/genType/src/Paths.res +++ b/res_syntax/tests/idempotency/genType/src/Paths.res @@ -9,7 +9,7 @@ let rec findProjectRoot = (~dir) => let parent = dir |> Filename.dirname if parent == dir { prerr_endline("Error: cannot find project root containing " ++ (bsconfig ++ ".")) - assert false + assert(false) } else { findProjectRoot(~dir=parent) } diff --git a/res_syntax/tests/idempotency/genType/src/TypeVars.res b/res_syntax/tests/idempotency/genType/src/TypeVars.res index 00a814ec4f..08d27a6864 100644 --- a/res_syntax/tests/idempotency/genType/src/TypeVars.res +++ b/res_syntax/tests/idempotency/genType/src/TypeVars.res @@ -5,7 +5,7 @@ let extractFromTypeExpr = typeParams => typeParams |> List.fold_left((soFar, typ | {Types.desc: Tvar(Some(s))} => let typeName = s list{typeName, ...soFar} - | _ => assert false + | _ => assert(false) } , list{}) |> List.rev diff --git a/res_syntax/tests/idempotency/ludum-dare-46/FlappyBird.res b/res_syntax/tests/idempotency/ludum-dare-46/FlappyBird.res index b20f860379..516ae36b32 100644 --- a/res_syntax/tests/idempotency/ludum-dare-46/FlappyBird.res +++ b/res_syntax/tests/idempotency/ludum-dare-46/FlappyBird.res @@ -176,7 +176,7 @@ let drawBird = ({pos: (x, y), img} as state, env) => { ~texHeight=17, env, ) - | _ => assert false + | _ => assert(false) } Draw.popMatrix(env) } diff --git a/res_syntax/tests/idempotency/ludum-dare-46/index.res b/res_syntax/tests/idempotency/ludum-dare-46/index.res index b58b5a1705..ab00622795 100644 --- a/res_syntax/tests/idempotency/ludum-dare-46/index.res +++ b/res_syntax/tests/idempotency/ludum-dare-46/index.res @@ -571,7 +571,7 @@ let drawLines = (map, env) => { ) | turn => (turnFacing(currFacing, turn), list{prevPoint, ...rest}) } - | _ => assert false + | _ => assert(false) }, ( facing, diff --git a/res_syntax/tests/idempotency/reprocessing/Reprocessing_Matrix.res b/res_syntax/tests/idempotency/reprocessing/Reprocessing_Matrix.res index 1a8ac9d7de..d82b06b98b 100644 --- a/res_syntax/tests/idempotency/reprocessing/Reprocessing_Matrix.res +++ b/res_syntax/tests/idempotency/reprocessing/Reprocessing_Matrix.res @@ -39,7 +39,7 @@ let matmatmul = (mat1: array, mat2: array) => mat1[6] = ma *. m6 +. md *. m7 +. mg *. m8 mat1[7] = mb *. m6 +. me *. m7 +. mh *. m8 mat1[8] = mc *. m6 +. mf *. m7 +. mi *. m8 - | _ => assert false + | _ => assert(false) } /* ** @@ -101,5 +101,5 @@ let matinv = mat => invdet *. adj21, invdet *. adj22, ] - | _ => assert false + | _ => assert(false) } diff --git a/res_syntax/tests/oprint/oprint.res b/res_syntax/tests/oprint/oprint.res index 5caa4461cc..4e0a3d35f5 100644 --- a/res_syntax/tests/oprint/oprint.res +++ b/res_syntax/tests/oprint/oprint.res @@ -12,14 +12,14 @@ module Set = { module Make = (Ord:OrderedType) : (S with type elt = Ord.t) => { type rec elt = Ord.t type rec t - let compare = assert false - let empty = assert false + let compare = assert(false) + let empty = assert(false) } } module Hashtbl = { type t<'a, 'b> - let create = (x:int) : t<_, _> => assert false + let create = (x:int) : t<_, _> => assert(false) } let name = "Steve" @@ -307,4 +307,4 @@ type call = CleanStart let f = (~a=1, ()) => 1 -type opt = {x:int, y?: option} \ No newline at end of file +type opt = {x:int, y?: option} diff --git a/res_syntax/tests/parsing/grammar/expressions/binary.res b/res_syntax/tests/parsing/grammar/expressions/binary.res index 79e3cf63b2..32cc091ef4 100644 --- a/res_syntax/tests/parsing/grammar/expressions/binary.res +++ b/res_syntax/tests/parsing/grammar/expressions/binary.res @@ -16,8 +16,8 @@ node := let x = z |> switch z {| _ => false} let x = z |> @attr switch z {| _ => false} -let x = z |> assert z -let x = z |> @attr assert z +let x = z |> assert(z) +let x = z |> @attr assert(z) let x = z |> lazy z let x = z |> @attr lazy z let x = z |> try sideEffect() catch { | _ => f() } diff --git a/res_syntax/tests/parsing/grammar/expressions/parenthesized.res b/res_syntax/tests/parsing/grammar/expressions/parenthesized.res index a88ec57de8..5efe5ba6bc 100644 --- a/res_syntax/tests/parsing/grammar/expressions/parenthesized.res +++ b/res_syntax/tests/parsing/grammar/expressions/parenthesized.res @@ -28,7 +28,7 @@ let blockExpression = ({ a + b }) -let assertSmthing = (assert true) +let assertSmthing = (assert(true)) let lazyThing = (lazy true) diff --git a/res_syntax/tests/printer/comments/blockExpr.res b/res_syntax/tests/printer/comments/blockExpr.res index 81f9cf9e90..665752d659 100644 --- a/res_syntax/tests/printer/comments/blockExpr.res +++ b/res_syntax/tests/printer/comments/blockExpr.res @@ -357,7 +357,7 @@ if { true } // trailing -assert { +assert({ // here open /* inside */ Matrix // c @@ -367,7 +367,7 @@ assert { // after // test -} +}) lazy { // here diff --git a/res_syntax/tests/printer/comments/case.res b/res_syntax/tests/printer/comments/case.res index a114ddd27e..784e0f3195 100644 --- a/res_syntax/tests/printer/comments/case.res +++ b/res_syntax/tests/printer/comments/case.res @@ -26,5 +26,5 @@ let rec mergeU = (s1, s2, f) => } let (l1, d1, r1) = split(v2, s1) N.concatOrJoin(mergeU(l1, l2, f), v2, f(. v2, d1, Some(d2)), mergeU(r1, r2, f)) - | _ => assert false + | _ => assert(false) } diff --git a/res_syntax/tests/printer/comments/expected/blockExpr.res.txt b/res_syntax/tests/printer/comments/expected/blockExpr.res.txt index f378abacd7..9dbc1248ed 100644 --- a/res_syntax/tests/printer/comments/expected/blockExpr.res.txt +++ b/res_syntax/tests/printer/comments/expected/blockExpr.res.txt @@ -354,7 +354,7 @@ if { true } // trailing -assert { +assert({ // here open /* inside */ Matrix // c @@ -364,7 +364,7 @@ assert { // after // test -} +}) lazy { // here diff --git a/res_syntax/tests/printer/comments/expected/case.res.txt b/res_syntax/tests/printer/comments/expected/case.res.txt index 4a51a7b08b..469af84df8 100644 --- a/res_syntax/tests/printer/comments/expected/case.res.txt +++ b/res_syntax/tests/printer/comments/expected/case.res.txt @@ -26,5 +26,5 @@ let rec mergeU = (s1, s2, f) => } let (l1, d1, r1) = split(v2, s1) N.concatOrJoin(mergeU(l1, l2, f), v2, f(. v2, d1, Some(d2)), mergeU(r1, r2, f)) - | _ => assert false + | _ => assert(false) } diff --git a/res_syntax/tests/printer/comments/expected/expr.res.txt b/res_syntax/tests/printer/comments/expected/expr.res.txt index c3ed1bf683..fc70428328 100644 --- a/res_syntax/tests/printer/comments/expected/expr.res.txt +++ b/res_syntax/tests/printer/comments/expected/expr.res.txt @@ -62,7 +62,7 @@ let x = { } // Pexp_assert -let x = /* here */ assert /* c0 */ true /* c1 */ +let x = /* here */ assert(/* c0 */ true /* c1 */) // Pexp_lazy let x = /* here */ lazy /* c0 */ true /* c1 */ diff --git a/res_syntax/tests/printer/comments/expected/whitespaceLeadingComment.res.txt b/res_syntax/tests/printer/comments/expected/whitespaceLeadingComment.res.txt index 188b4eb65d..70fb206784 100644 --- a/res_syntax/tests/printer/comments/expected/whitespaceLeadingComment.res.txt +++ b/res_syntax/tests/printer/comments/expected/whitespaceLeadingComment.res.txt @@ -9,5 +9,5 @@ let () = { Tuple.makePoint(0., Js.Math.sqrt(2.) /. 2., Js.Math.sqrt(2.) /. 2.), ) */ - assert Tuple.equals(fullQuarter->applyTo(point), Tuple.makePoint(0., 0., 1.)) + assert(Tuple.equals(fullQuarter->applyTo(point), Tuple.makePoint(0., 0., 1.))) } diff --git a/res_syntax/tests/printer/comments/expr.res b/res_syntax/tests/printer/comments/expr.res index c75a1f8ba5..a6c20dca71 100644 --- a/res_syntax/tests/printer/comments/expr.res +++ b/res_syntax/tests/printer/comments/expr.res @@ -62,7 +62,7 @@ let x = { } // Pexp_assert -let x = /* here */ assert /* c0 */ true /* c1 */ +let x = /* here */ assert( /* c0 */ true /* c1 */) // Pexp_lazy let x = /* here */ lazy /* c0 */ true /* c1 */ diff --git a/res_syntax/tests/printer/comments/whitespaceLeadingComment.res b/res_syntax/tests/printer/comments/whitespaceLeadingComment.res index 2ee46863b0..a06f3dcdea 100644 --- a/res_syntax/tests/printer/comments/whitespaceLeadingComment.res +++ b/res_syntax/tests/printer/comments/whitespaceLeadingComment.res @@ -9,5 +9,5 @@ let () = { Tuple.makePoint(0., Js.Math.sqrt(2.) /. 2., Js.Math.sqrt(2.) /. 2.), ) */ - assert Tuple.equals(fullQuarter->applyTo(point), Tuple.makePoint(0., 0., 1.)) + assert(Tuple.equals(fullQuarter->applyTo(point), Tuple.makePoint(0., 0., 1.))) } diff --git a/res_syntax/tests/printer/expr/asyncAwait.res b/res_syntax/tests/printer/expr/asyncAwait.res index 5d64207e13..e6cd380ec9 100644 --- a/res_syntax/tests/printer/expr/asyncAwait.res +++ b/res_syntax/tests/printer/expr/asyncAwait.res @@ -23,7 +23,7 @@ let maybeSomeValue = switch await fetchData(url) { await 1 + await 2 lazy (await f()) -assert (await f()) +assert(await f()) (await f).json() @@ -64,7 +64,7 @@ let _ = await (while true { infiniteLoop() }) let _ = await (try ok() catch { | _ => logError() }) let _ = await (for i in 0 to 10 { sideEffect()}) let _ = await (lazy x) -let _ = await (assert x) +let _ = await (assert(x)) let _ = await promises[0] let _ = await promises["resolved"] let _ = await (promises["resolved"] = sideEffect()) @@ -123,4 +123,4 @@ type t2 = (. int, string) => bool let f = async (type a, ()) => { await Js.Promise.resolve(()) -} \ No newline at end of file +} diff --git a/res_syntax/tests/printer/expr/binary.res b/res_syntax/tests/printer/expr/binary.res index 2b7dd15405..4d84f5526a 100644 --- a/res_syntax/tests/printer/expr/binary.res +++ b/res_syntax/tests/printer/expr/binary.res @@ -248,8 +248,8 @@ let x = a && {module L = Log; L.log()} && {module L = Log; L.log()} let x = a && {exception Exit; raise(Exit)} let x = a && {exception Exit; raise(Exit)} && {exception Exit; raise(Exit)} -let x = a && assert false -let x = a && assert false && assert true +let x = a && assert(false) +let x = a && assert(false) && assert(true) let x = a && lazy false let x = a && lazy false && lazy true diff --git a/res_syntax/tests/printer/expr/braced.res b/res_syntax/tests/printer/expr/braced.res index b04096026e..93f463ca74 100644 --- a/res_syntax/tests/printer/expr/braced.res +++ b/res_syntax/tests/printer/expr/braced.res @@ -124,8 +124,8 @@ map(( x +. (Environment.width /. 2. -. centering.x) }) -let _ = assert { true } -let _ = { assert { true } } +let _ = assert({ true }) +let _ = { assert({ true }) } let _ = { lazy { true } } let _ = { %extension } diff --git a/res_syntax/tests/printer/expr/exoticIdent.res b/res_syntax/tests/printer/expr/exoticIdent.res index c68bffd655..afec5bd3f4 100644 --- a/res_syntax/tests/printer/expr/exoticIdent.res +++ b/res_syntax/tests/printer/expr/exoticIdent.res @@ -43,7 +43,7 @@ let () = { let x = (\"type" : \"module") -assert \"let" +assert(\"let") lazy \"let" diff --git a/res_syntax/tests/printer/expr/expected/assert.res.txt b/res_syntax/tests/printer/expr/expected/assert.res.txt index 513959c763..593516a11b 100644 --- a/res_syntax/tests/printer/expr/expected/assert.res.txt +++ b/res_syntax/tests/printer/expr/expected/assert.res.txt @@ -1,69 +1,59 @@ -assert false - -assert truth - -let x = assert true -let x = assert 12 -let x = assert (12: int) -let x = assert 12 -let x = assert list{1, 2, ...x} -let x = assert module(Foo: Bar) -let x = assert module(Foo) -let x = assert Rgb(1, 2, 3) -let x = assert [a, b, c] -let x = assert {x: 1, y: 3} -let x = assert (1, 2, 3) -let x = assert %extension -let x = assert user.name -let x = assert streets[0] -let x = assert apply(arg1, arg2) -let x = assert apply(. arg1, arg2) -let x = assert -1 -let x = assert !true -let x = assert (x => print(x)) -let x = assert ( - switch x { - | Blue => () - | Yello => () - } -) - -let x = assert ( - for i in 0 to 10 { - print_int(i) - } -) - -let x = assert ( - if i < 10 { - print_int(i) - } else { - print_int(1000) - } -) - -let x = assert ( - while i < 10 { - print_int(i) - } -) - -let x = assert (lazy false) -let x = assert ( - try sideEffect() catch { - | Exit => () - } -) - -let x = assert (@attr expr) - -let x = assert (a + b) - -let x = @attr assert false - -assert invariant["fatal"] -assert invariants[0] - -assert address["street"] = "Brusselsestraat" - -assert (true ? 0 : 1) +assert(false) + +assert(truth) + +let x = assert(true) +let x = assert(12) +let x = assert(12: int) +let x = assert(12) +let x = assert(list{1, 2, ...x}) +let x = assert(module(Foo: Bar)) +let x = assert(module(Foo)) +let x = assert(Rgb(1, 2, 3)) +let x = assert([a, b, c]) +let x = assert({x: 1, y: 3}) +let x = assert((1, 2, 3)) +let x = assert(%extension) +let x = assert(user.name) +let x = assert(streets[0]) +let x = assert(apply(arg1, arg2)) +let x = assert(apply(. arg1, arg2)) +let x = assert(-1) +let x = assert(!true) +let x = assert(x => print(x)) +let x = assert(switch x { +| Blue => () +| Yello => () +}) + +let x = assert(for i in 0 to 10 { + print_int(i) +}) + +let x = assert(if i < 10 { + print_int(i) +} else { + print_int(1000) +}) + +let x = assert(while i < 10 { + print_int(i) +}) + +let x = assert(lazy false) +let x = assert(try sideEffect() catch { +| Exit => () +}) + +let x = assert(@attr expr) + +let x = assert(a + b) + +let x = @attr assert(false) + +assert(invariant["fatal"]) +assert(invariants[0]) + +assert(address["street"] = "Brusselsestraat") + +assert(true ? 0 : 1) diff --git a/res_syntax/tests/printer/expr/expected/asyncAwait.res.txt b/res_syntax/tests/printer/expr/expected/asyncAwait.res.txt index 1b2968683c..20da7e35f9 100644 --- a/res_syntax/tests/printer/expr/expected/asyncAwait.res.txt +++ b/res_syntax/tests/printer/expr/expected/asyncAwait.res.txt @@ -22,7 +22,7 @@ let maybeSomeValue = switch await fetchData(url) { (await 1) + (await 2) lazy (await f()) -assert (await f()) +assert(await f()) (await f).json() @@ -86,7 +86,7 @@ let _ = await ( } ) let _ = await (lazy x) -let _ = await (assert x) +let _ = await (assert(x)) let _ = await promises[0] let _ = await promises["resolved"] let _ = await promises["resolved"] = sideEffect() diff --git a/res_syntax/tests/printer/expr/expected/binary.res.txt b/res_syntax/tests/printer/expr/expected/binary.res.txt index 9ea7e7b35a..a699c3261f 100644 --- a/res_syntax/tests/printer/expr/expected/binary.res.txt +++ b/res_syntax/tests/printer/expr/expected/binary.res.txt @@ -370,8 +370,8 @@ let x = raise(Exit) } -let x = a && assert false -let x = a && assert false && assert true +let x = a && assert(false) +let x = a && assert(false && assert(true)) let x = a && lazy false let x = a && lazy false && lazy true diff --git a/res_syntax/tests/printer/expr/expected/braced.res.txt b/res_syntax/tests/printer/expr/expected/braced.res.txt index 542fb49940..d60e067b4f 100644 --- a/res_syntax/tests/printer/expr/expected/braced.res.txt +++ b/res_syntax/tests/printer/expr/expected/braced.res.txt @@ -206,8 +206,8 @@ map((arr, i): coordinate => { x +. (Environment.width /. 2. -. centering.x) }) -let _ = assert {true} -let _ = {assert {true}} +let _ = assert(true) +let _ = {assert(true)} let _ = {lazy {true}} let _ = {%extension} diff --git a/res_syntax/tests/printer/expr/expected/exoticIdent.res.txt b/res_syntax/tests/printer/expr/expected/exoticIdent.res.txt index 4453cea526..d3dc9ecd77 100644 --- a/res_syntax/tests/printer/expr/expected/exoticIdent.res.txt +++ b/res_syntax/tests/printer/expr/expected/exoticIdent.res.txt @@ -51,7 +51,7 @@ let () = { let x = (\"type": \"module") -assert \"let" +assert(\"let") lazy \"let" diff --git a/res_syntax/tests/printer/expr/expected/field.res.txt b/res_syntax/tests/printer/expr/expected/field.res.txt index c005729762..642e540c3f 100644 --- a/res_syntax/tests/printer/expr/expected/field.res.txt +++ b/res_syntax/tests/printer/expr/expected/field.res.txt @@ -48,7 +48,7 @@ let x = ( } ).x -let x = (assert false).x +let x = (assert(false)).x let x = (lazy false).x let x = ( try sideEffect() catch { diff --git a/res_syntax/tests/printer/expr/expected/jsx.res.txt b/res_syntax/tests/printer/expr/expected/jsx.res.txt index 4b9e5f970e..35f7b9ef58 100644 --- a/res_syntax/tests/printer/expr/expected/jsx.res.txt +++ b/res_syntax/tests/printer/expr/expected/jsx.res.txt @@ -181,7 +181,7 @@ let x = raise(Exit) } lazyExpr={lazy stuff()} - assertExpr={assert true} + assertExpr={assert(true)} pack=module(Foo) pack={module(Foo)} pack=module(Foo: Bar) @@ -261,7 +261,7 @@ let x = raise(Exit) } {lazy stuff()} - {assert true} + {assert(true)} {module(Foo)} module(Foo) {module(Foo: Bar)} diff --git a/res_syntax/tests/printer/expr/expected/lazy.res.txt b/res_syntax/tests/printer/expr/expected/lazy.res.txt index 8d1e6dc2bc..ac1a44b006 100644 --- a/res_syntax/tests/printer/expr/expected/lazy.res.txt +++ b/res_syntax/tests/printer/expr/expected/lazy.res.txt @@ -47,7 +47,7 @@ let x = lazy ( } ) -let x = lazy (assert false) +let x = lazy (assert(false)) let x = lazy ( try sideEffect() catch { | Exit => () diff --git a/res_syntax/tests/printer/expr/expected/ternary.res.txt b/res_syntax/tests/printer/expr/expected/ternary.res.txt index 197e578113..21a26a3d19 100644 --- a/res_syntax/tests/printer/expr/expected/ternary.res.txt +++ b/res_syntax/tests/printer/expr/expected/ternary.res.txt @@ -219,7 +219,7 @@ let () = condition exception Exit raise(Exit) } -let () = condition ? lazy foo() : assert false +let () = condition ? lazy foo() : assert(false) let x = condition ? module(Foo) : module(Int: Number) let x = condition diff --git a/res_syntax/tests/printer/expr/expected/unary.res.txt b/res_syntax/tests/printer/expr/expected/unary.res.txt index bcc02aa52b..cfe9b42193 100644 --- a/res_syntax/tests/printer/expr/expected/unary.res.txt +++ b/res_syntax/tests/printer/expr/expected/unary.res.txt @@ -26,8 +26,8 @@ let x = -a.bar !(lazy x) lazy !x -!(assert x) -assert !x +!(assert(x)) +assert(!x) !(@attr expr) !(arg => doStuffWith(arg)) let x = !(truth: bool) diff --git a/res_syntax/tests/printer/expr/expected/underscoreApply.res.txt b/res_syntax/tests/printer/expr/expected/underscoreApply.res.txt index 1be54d859f..38d46244f6 100644 --- a/res_syntax/tests/printer/expr/expected/underscoreApply.res.txt +++ b/res_syntax/tests/printer/expr/expected/underscoreApply.res.txt @@ -38,7 +38,7 @@ f(a, b, _)(x, y) f(a, b, _) + g(x, _, z) f(a, b, _) + g(x, _, z) + h(alpha, beta, _) -assert f(a, b, _) +assert(f(a, b, _)) lazy f(a, b, _) getDirector(a, b, _).name diff --git a/res_syntax/tests/printer/expr/field.res b/res_syntax/tests/printer/expr/field.res index 9175a60009..918f7c0eea 100644 --- a/res_syntax/tests/printer/expr/field.res +++ b/res_syntax/tests/printer/expr/field.res @@ -41,7 +41,7 @@ let x = (while i < 10 { print_int(i) }).x -let x = (assert false).x +let x = (assert(false)).x let x = (lazy false).x let x = (try sideEffect() catch {| Exit => ()}).x diff --git a/res_syntax/tests/printer/expr/jsx.res b/res_syntax/tests/printer/expr/jsx.res index 95a7e14ce1..074d89769f 100644 --- a/res_syntax/tests/printer/expr/jsx.res +++ b/res_syntax/tests/printer/expr/jsx.res @@ -173,7 +173,7 @@ let x = raise(Exit) }} lazyExpr={lazy stuff()} - assertExpr={assert true} + assertExpr={assert(true)} pack=module(Foo) pack={module(Foo)} pack=module(Foo: Bar) @@ -245,7 +245,7 @@ let x = raise(Exit) }} {lazy stuff()} - {assert true} + {assert(true)} {module(Foo)} module(Foo) {module(Foo: Bar)} @@ -409,4 +409,4 @@ let x = props => \ No newline at end of file + /> diff --git a/res_syntax/tests/printer/expr/lazy.res b/res_syntax/tests/printer/expr/lazy.res index 17e2703ac2..9d0fd7b04a 100644 --- a/res_syntax/tests/printer/expr/lazy.res +++ b/res_syntax/tests/printer/expr/lazy.res @@ -39,7 +39,7 @@ let x = lazy (while i < 10 { print_int(i) }) -let x = lazy (assert false) +let x = lazy (assert(false)) let x = lazy (try sideEffect() catch {| Exit => ()}) let x = lazy (@attr expr) diff --git a/res_syntax/tests/printer/expr/ternary.res b/res_syntax/tests/printer/expr/ternary.res index d8a8a36086..8476516155 100644 --- a/res_syntax/tests/printer/expr/ternary.res +++ b/res_syntax/tests/printer/expr/ternary.res @@ -99,7 +99,7 @@ let () = condition1 ? for i in 0 to 10 { () } : for i in 10 to 20 { () } let () = (truth : bool) ? (10: int) : (20: int) let () = condition ? {module L = Logger; L.log()} : {exception Exit; raise(Exit)} -let () = condition ? lazy foo() : assert false +let () = condition ? lazy foo() : assert(false) let x = condition ? module(Foo) : module(Int : Number) let x = condition ? module(ModuleWithVeryLooooooooooooooooongNameHere) : module(ModuleWithVeryLooooooooooooooooongNameHereInt : Number) diff --git a/res_syntax/tests/printer/expr/unary.res b/res_syntax/tests/printer/expr/unary.res index 2a33331665..0aba0aea7e 100644 --- a/res_syntax/tests/printer/expr/unary.res +++ b/res_syntax/tests/printer/expr/unary.res @@ -27,8 +27,8 @@ let x = -(a.bar) !(lazy x) lazy !x -!(assert x) -assert !x +!(assert(x)) +assert(!x) !(@attr expr) !(arg => doStuffWith(arg)) let x = !(truth: bool) diff --git a/res_syntax/tests/printer/expr/underscoreApply.res b/res_syntax/tests/printer/expr/underscoreApply.res index bbd2cecfbc..373f365550 100644 --- a/res_syntax/tests/printer/expr/underscoreApply.res +++ b/res_syntax/tests/printer/expr/underscoreApply.res @@ -40,7 +40,7 @@ f(a, b, _)(x, y) f(a, b, _) + g(x, _, z) f(a, b, _) + g(x, _, z) + h(alpha, beta, _) -assert f(a, b, _) +assert(f(a, b, _)) lazy f(a, b, _) getDirector(a, b, _).name diff --git a/res_syntax/tests/printer/pattern/construct.res b/res_syntax/tests/printer/pattern/construct.res index 691e680e93..f2f86f77a7 100644 --- a/res_syntax/tests/printer/pattern/construct.res +++ b/res_syntax/tests/printer/pattern/construct.res @@ -16,8 +16,8 @@ switch truth { } switch sphere->intersect(~ray) { -| None => assert false -| Some((x, y)) => assert true +| None => assert(false) +| Some((x, y)) => assert(true) } diff --git a/res_syntax/tests/printer/pattern/expected/construct.res.txt b/res_syntax/tests/printer/pattern/expected/construct.res.txt index a8145d61ed..d464746d97 100644 --- a/res_syntax/tests/printer/pattern/expected/construct.res.txt +++ b/res_syntax/tests/printer/pattern/expected/construct.res.txt @@ -16,8 +16,8 @@ switch truth { } switch sphere->intersect(~ray) { -| None => assert false -| Some((x, y)) => assert true +| None => assert(false) +| Some((x, y)) => assert(true) } // huggable patterns