Fuzzer bugs

[aleksisch]

This issue will store bugs found by fuzzer (fixed ones will be marked by ✅):

tuple var2{}
[export] def main{print("{ -- !var2(){} -- }");}

[export] def main{ print("{var1()$():var3&{}}");}

[export] def main{ print("{+ new  variant <var3:var3-&?>()}");}

[export] def main{ print("{7+2 <<  class < :: var2?>()}");} finally {}

 class s1{
}
 enum s2{
,v2=(!~4 ^^ 5/(0),5,v3-f1(!0%7+2 <= f1(3>5)+@@ => !1>0.))}

[export]
def f1(){
[1];
}

[export]
def main{
print("{+(5)&5*~2 != +5+4 >>>  new s2(v3=3)}");}

 class s1{
def f1(){
} finally {
}
v2 <- 6+2;
v1=+ new s1[-27];
}
 enum s2{
}

[export]
def f1{
 pass ;
7=6;
} finally {
}

[export]
def main{
print("{1 <= 4>@@f1}");}

 tuple var3{
}
 enum var3{
var2,,}
;
 enum var3: int64 {
var1=var1 :: var3(!8/4+8? as var3){
}
}

[export]
def var3{
}

[export]
def main{
print("{1 -> var3() != [] as var3.var2}");}

 tuple var1{ var1-# const ; }
 var var3:var1&-& ==  const ;

[export]
def main{
print("{ null }");} finally {}

 enum var1{}
 enum var1{ var2= "  { 7%3 }  {  " }

[export] def main{print("{ :: var2(var2 := 6 as  int4 ,)}");} finally {}

 var {
}
 enum var2: uint64 {
var1=-[] <<< 7 != 2 -> var1(~0)&${
}
}

[export]
def main{
print("{[5] .. []/3/4.[-5*6] == var2(var3 := ~9,){
}
}");} finally {
60 if (+4<1 >= 1 && 5);
}

 variant var2{
}
 tuple var3{
var1: block  ?? }
;

[export]
def var3:var3?{
;
2;
}

[export]
def main{
;
print("{(+9,).var1([var3=1/2]).var3()}");} finally {
 assume var2=9. ?[ +1[ "  " ]];
}

 bitfield var1{
,var3,}

[export]
def var1: block ?- const {
} finally {
;
}

[export]
def main{ print("{-~9 |> var3. ?. var2}");}

 enum var1{
}
 enum var1{
,,var3,var3=8.31.var1([var2 <- (var1=4<6,)])+!-0. uint4 (2),}

[export]
def main{
print("{var2 :: var2.[2 <= 6 >= 7 ?[ 20<0]]}");}

 variant var2{
var2: block <: bitfield >-#}

[export]
def main{
print("{ new var2}");} finally {}

 var var3:var1=0-~0 && 6+7?2:-~7;

[export]
def main{
print("{888<8^!4 == 6+[]. ?[ ~5+8] && ~-+-1<!9 is var2}");} finally { pass ; }

variant var1{}
[export] def main{ print("{1 >> [] >=  uint ()}");} finally { return ; var  inscope (var2)=(var1=-4,); }

variant var3{ var2:var3- const ; }
[export] def var2: table <var3>{}
[export] def main{ print("{9 != 4*3}");}

enum var3{}

[export]
def var2( var var3:var2=var2()){ with ([]){}}

[export]
def main{print("{392}");}

 tuple var1{
var1;
int4 #;
}
let var3: block <var1&?>&;

[export]
def main{print("{(var3=[],var1 := 1/~3 is var3)}");} finally {}

[imp5imp5]

options gen2
options optimize = true
require strings
require math
require daslib/strings_boost
def apply_int(val : int; blk : block<(x:int):int>) : int {
    return invoke(blk, val)
}

def check_int(val : int; blk : block<(x:int):bool>) : bool {
    return invoke(blk, val)
}


[export]
def main {
    print("===\n")
    try {
        // === Code Bricks assembly - seed 1171 ===
        let v0 = -(((false ? 128 : (-100)) + (-2147483647)))  // [expr_int]
        let v1 = "foo"  // [string_literal]
        let v2 = float((1024 & (v0 - v0)))  // [expr_float]
        let v3 = replace(v1, " ", "hello")  // [string_replace]
        let v4 = v2 < float(v0)  // [float_int_cmp_lt]
        let v5 = sin(v2)  // [float_sin]
        let v6 = v4 ? v3 : v1  // [ternary_str]
    } recover {
        print("PANIC\n")
    }
    print("===\n")
}

[borisbat]

#2133 - first portion

[borisbat]

#2134 - second portion
at this point everything above no longer crashes

[aleksisch]

Created metaissue