X-Git-Url: http://nitlanguage.org diff --git a/c_src/nit__separate_compiler.sep.2.c b/c_src/nit__separate_compiler.sep.2.c index c03e39c..614be31 100644 --- a/c_src/nit__separate_compiler.sep.2.c +++ b/c_src/nit__separate_compiler.sep.2.c @@ -1,4 +1,542 @@ #include "nit__separate_compiler.sep.0.h" +/* method separate_compiler#SeparateCompiler#compile_type_resolution_table for (self: SeparateCompiler, MType) */ +void nit___nit__SeparateCompiler___compile_type_resolution_table(val* self, val* p0) { +val* var_mtype /* var mtype: MType */; +val* var /* : MType */; +short int var1 /* : Bool */; +int cltype; +int idtype; +const char* var_class_name; +val* var_mclass_type /* var mclass_type: MClassType */; +val* var2 /* : NativeArray[String] */; +static val* varonce; +static val* varonce3; +val* var4 /* : String */; +char* var5 /* : NativeString */; +val* var6 /* : FlatString */; +val* var7 /* : String */; +val* var8 /* : String */; +val* var10 /* : NativeArray[String] */; +static val* varonce9; +static val* varonce11; +val* var12 /* : String */; +char* var13 /* : NativeString */; +val* var14 /* : FlatString */; +static val* varonce15; +val* var16 /* : String */; +char* var17 /* : NativeString */; +val* var18 /* : FlatString */; +val* var19 /* : String */; +val* var20 /* : String */; +val* var21 /* : AbstractCompilerVisitor */; +val* var_v /* var v: SeparateCompilerVisitor */; +val* var23 /* : NativeArray[String] */; +static val* varonce22; +static val* varonce24; +val* var25 /* : String */; +char* var26 /* : NativeString */; +val* var27 /* : FlatString */; +static val* varonce28; +val* var29 /* : String */; +char* var30 /* : NativeString */; +val* var31 /* : FlatString */; +val* var32 /* : String */; +val* var33 /* : String */; +static val* varonce34; +val* var35 /* : String */; +char* var36 /* : NativeString */; +val* var37 /* : FlatString */; +static val* varonce38; +val* var39 /* : String */; +char* var40 /* : NativeString */; +val* var41 /* : FlatString */; +val* var42 /* : Map[MClassType, Array[nullable MType]] */; +val* var44 /* : Map[MClassType, Array[nullable MType]] */; +val* var45 /* : nullable Object */; +val* var_ /* var : Array[nullable MType] */; +val* var46 /* : ArrayIterator[nullable Object] */; +val* var_47 /* var : ArrayIterator[nullable MType] */; +short int var48 /* : Bool */; +val* var49 /* : nullable Object */; +val* var_t /* var t: nullable MType */; +short int var50 /* : Bool */; +short int var51 /* : Bool */; +val* var_other /* var other: nullable Object */; +short int var53 /* : Bool */; +short int var55 /* : Bool */; +static val* varonce56; +val* var57 /* : String */; +char* var58 /* : NativeString */; +val* var59 /* : FlatString */; +val* var60 /* : MModule */; +val* var62 /* : MModule */; +val* var63 /* : MType */; +val* var_tv /* var tv: MType */; +val* var64 /* : Map[MType, Int] */; +val* var66 /* : Map[MType, Int] */; +short int var67 /* : Bool */; +val* var69 /* : NativeArray[String] */; +static val* varonce68; +static val* varonce70; +val* var71 /* : String */; +char* var72 /* : NativeString */; +val* var73 /* : FlatString */; +val* var74 /* : String */; +val* var75 /* : String */; +val* var77 /* : NativeArray[String] */; +static val* varonce76; +static val* varonce78; +val* var79 /* : String */; +char* var80 /* : NativeString */; +val* var81 /* : FlatString */; +static val* varonce82; +val* var83 /* : String */; +char* var84 /* : NativeString */; +val* var85 /* : FlatString */; +static val* varonce86; +val* var87 /* : String */; +char* var88 /* : NativeString */; +val* var89 /* : FlatString */; +static val* varonce90; +val* var91 /* : String */; +char* var92 /* : NativeString */; +val* var93 /* : FlatString */; +val* var94 /* : String */; +val* var95 /* : String */; +val* var96 /* : String */; +val* var97 /* : String */; +val* var99 /* : NativeArray[String] */; +static val* varonce98; +static val* varonce100; +val* var101 /* : String */; +char* var102 /* : NativeString */; +val* var103 /* : FlatString */; +static val* varonce104; +val* var105 /* : String */; +char* var106 /* : NativeString */; +val* var107 /* : FlatString */; +static val* varonce108; +val* var109 /* : String */; +char* var110 /* : NativeString */; +val* var111 /* : FlatString */; +val* var112 /* : String */; +val* var113 /* : String */; +val* var114 /* : String */; +static val* varonce115; +val* var116 /* : String */; +char* var117 /* : NativeString */; +val* var118 /* : FlatString */; +static val* varonce119; +val* var120 /* : String */; +char* var121 /* : NativeString */; +val* var122 /* : FlatString */; +var_mtype = p0; +{ +var = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nit__model__MType__undecorate]))(var_mtype); /* undecorate on */ +} +/* isa MClassType */ +cltype = type_nit__MClassType.color; +idtype = type_nit__MClassType.id; +if(cltype >= var->type->table_size) { +var1 = 0; +} else { +var1 = var->type->type_table[cltype] == idtype; +} +if (unlikely(!var1)) { +var_class_name = var == NULL ? "null" : var->type->name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 780); +fatal_exit(1); +} +var_mclass_type = var; +if (unlikely(varonce==NULL)) { +var2 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce3!=NULL)) { +var4 = varonce3; +} else { +var5 = "resolution_table_"; +var6 = standard___standard__NativeString___to_s_with_length(var5, 17l); +var4 = var6; +varonce3 = var4; +} +((struct instance_standard__NativeArray*)var2)->values[0]=var4; +} else { +var2 = varonce; +varonce = NULL; +} +{ +var7 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_mtype); /* c_name on */ +} +((struct instance_standard__NativeArray*)var2)->values[1]=var7; +{ +var8 = ((val*(*)(val* self))(var2->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var2); /* native_to_s on */ +} +varonce = var2; +if (unlikely(varonce9==NULL)) { +var10 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce11!=NULL)) { +var12 = varonce11; +} else { +var13 = "extern const struct types resolution_table_"; +var14 = standard___standard__NativeString___to_s_with_length(var13, 43l); +var12 = var14; +varonce11 = var12; +} +((struct instance_standard__NativeArray*)var10)->values[0]=var12; +if (likely(varonce15!=NULL)) { +var16 = varonce15; +} else { +var17 = ";"; +var18 = standard___standard__NativeString___to_s_with_length(var17, 1l); +var16 = var18; +varonce15 = var16; +} +((struct instance_standard__NativeArray*)var10)->values[2]=var16; +} else { +var10 = varonce9; +varonce9 = NULL; +} +{ +var19 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_mtype); /* c_name on */ +} +((struct instance_standard__NativeArray*)var10)->values[1]=var19; +{ +var20 = ((val*(*)(val* self))(var10->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var10); /* native_to_s on */ +} +varonce9 = var10; +{ +nit___nit__AbstractCompiler___provide_declaration(self, var8, var20); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ +} +{ +var21 = ((val*(*)(val* self))(self->class->vft[COLOR_nit__abstract_compiler__AbstractCompiler__new_visitor]))(self); /* new_visitor on */ +} +var_v = var21; +if (unlikely(varonce22==NULL)) { +var23 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce24!=NULL)) { +var25 = varonce24; +} else { +var26 = "const struct types resolution_table_"; +var27 = standard___standard__NativeString___to_s_with_length(var26, 36l); +var25 = var27; +varonce24 = var25; +} +((struct instance_standard__NativeArray*)var23)->values[0]=var25; +if (likely(varonce28!=NULL)) { +var29 = varonce28; +} else { +var30 = " = {"; +var31 = standard___standard__NativeString___to_s_with_length(var30, 4l); +var29 = var31; +varonce28 = var29; +} +((struct instance_standard__NativeArray*)var23)->values[2]=var29; +} else { +var23 = varonce22; +varonce22 = NULL; +} +{ +var32 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_mtype); /* c_name on */ +} +((struct instance_standard__NativeArray*)var23)->values[1]=var32; +{ +var33 = ((val*(*)(val* self))(var23->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var23); /* native_to_s on */ +} +varonce22 = var23; +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var33); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (likely(varonce34!=NULL)) { +var35 = varonce34; +} else { +var36 = "0, /* dummy */"; +var37 = standard___standard__NativeString___to_s_with_length(var36, 14l); +var35 = var37; +varonce34 = var35; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var35); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (likely(varonce38!=NULL)) { +var39 = varonce38; +} else { +var40 = "{"; +var41 = standard___standard__NativeString___to_s_with_length(var40, 1l); +var39 = var41; +varonce38 = var39; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var39); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +{ +{ /* Inline separate_compiler#SeparateCompiler#resolution_tables (self) on */ +var44 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___resolution_tables].val; /* _resolution_tables on */ +if (unlikely(var44 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _resolution_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 1052); +fatal_exit(1); +} +var42 = var44; +RET_LABEL43:(void)0; +} +} +{ +var45 = ((val*(*)(val* self, val* p0))((((long)var42&3)?class_info[((long)var42&3)]:var42->class)->vft[COLOR_standard__abstract_collection__MapRead___91d_93d]))(var42, var_mclass_type); /* [] on */ +} +var_ = var45; +{ +var46 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_); +} +var_47 = var46; +for(;;) { +{ +var48 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_47); +} +if (var48){ +{ +var49 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_47); +} +var_t = var49; +if (var_t == NULL) { +var50 = 1; /* is null */ +} else { +var50 = 0; /* arg is null but recv is not */ +} +if (0) { +{ /* Inline kernel#Object#== (var_t,((val*)NULL)) on */ +var_other = ((val*)NULL); +{ +{ /* Inline kernel#Object#is_same_instance (var_t,var_other) on */ +var55 = var_t == var_other; +var53 = var55; +goto RET_LABEL54; +RET_LABEL54:(void)0; +} +} +var51 = var53; +goto RET_LABEL52; +RET_LABEL52:(void)0; +} +var50 = var51; +} +if (var50){ +if (likely(varonce56!=NULL)) { +var57 = varonce56; +} else { +var58 = "NULL, /* empty */"; +var59 = standard___standard__NativeString___to_s_with_length(var58, 17l); +var57 = var59; +varonce56 = var57; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var57); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} else { +{ +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var62 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var62 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 515); +fatal_exit(1); +} +var60 = var62; +RET_LABEL61:(void)0; +} +} +{ +var63 = ((val*(*)(val* self, val* p0, val* p1, val* p2, short int p3))(var_t->class->vft[COLOR_nit__model__MType__resolve_for]))(var_t, var_mclass_type, var_mclass_type, var60, 1); /* resolve_for on */ +} +var_tv = var63; +{ +{ /* Inline separate_compiler#SeparateCompiler#type_ids (self) on */ +var66 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___type_ids].val; /* _type_ids on */ +if (unlikely(var66 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _type_ids"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 149); +fatal_exit(1); +} +var64 = var66; +RET_LABEL65:(void)0; +} +} +{ +var67 = ((short int(*)(val* self, val* p0))((((long)var64&3)?class_info[((long)var64&3)]:var64->class)->vft[COLOR_standard__abstract_collection__MapRead__has_key]))(var64, var_tv); /* has_key on */ +} +if (var67){ +if (unlikely(varonce68==NULL)) { +var69 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce70!=NULL)) { +var71 = varonce70; +} else { +var72 = "type_"; +var73 = standard___standard__NativeString___to_s_with_length(var72, 5l); +var71 = var73; +varonce70 = var71; +} +((struct instance_standard__NativeArray*)var69)->values[0]=var71; +} else { +var69 = varonce68; +varonce68 = NULL; +} +{ +var74 = ((val*(*)(val* self))(var_tv->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_tv); /* c_name on */ +} +((struct instance_standard__NativeArray*)var69)->values[1]=var74; +{ +var75 = ((val*(*)(val* self))(var69->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var69); /* native_to_s on */ +} +varonce68 = var69; +{ +nit___nit__AbstractCompilerVisitor___require_declaration(var_v, var75); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +} +if (unlikely(varonce76==NULL)) { +var77 = NEW_standard__NativeArray(7l, &type_standard__NativeArray__standard__String); +if (likely(varonce78!=NULL)) { +var79 = varonce78; +} else { +var80 = "&type_"; +var81 = standard___standard__NativeString___to_s_with_length(var80, 6l); +var79 = var81; +varonce78 = var79; +} +((struct instance_standard__NativeArray*)var77)->values[0]=var79; +if (likely(varonce82!=NULL)) { +var83 = varonce82; +} else { +var84 = ", /* "; +var85 = standard___standard__NativeString___to_s_with_length(var84, 5l); +var83 = var85; +varonce82 = var83; +} +((struct instance_standard__NativeArray*)var77)->values[2]=var83; +if (likely(varonce86!=NULL)) { +var87 = varonce86; +} else { +var88 = ": "; +var89 = standard___standard__NativeString___to_s_with_length(var88, 2l); +var87 = var89; +varonce86 = var87; +} +((struct instance_standard__NativeArray*)var77)->values[4]=var87; +if (likely(varonce90!=NULL)) { +var91 = varonce90; +} else { +var92 = " */"; +var93 = standard___standard__NativeString___to_s_with_length(var92, 3l); +var91 = var93; +varonce90 = var91; +} +((struct instance_standard__NativeArray*)var77)->values[6]=var91; +} else { +var77 = varonce76; +varonce76 = NULL; +} +{ +var94 = ((val*(*)(val* self))(var_tv->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_tv); /* c_name on */ +} +((struct instance_standard__NativeArray*)var77)->values[1]=var94; +{ +var95 = ((val*(*)(val* self))(var_t->class->vft[COLOR_standard__string__Object__to_s]))(var_t); /* to_s on */ +} +((struct instance_standard__NativeArray*)var77)->values[3]=var95; +{ +var96 = ((val*(*)(val* self))(var_tv->class->vft[COLOR_standard__string__Object__to_s]))(var_tv); /* to_s on */ +} +((struct instance_standard__NativeArray*)var77)->values[5]=var96; +{ +var97 = ((val*(*)(val* self))(var77->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var77); /* native_to_s on */ +} +varonce76 = var77; +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var97); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} else { +if (unlikely(varonce98==NULL)) { +var99 = NEW_standard__NativeArray(5l, &type_standard__NativeArray__standard__String); +if (likely(varonce100!=NULL)) { +var101 = varonce100; +} else { +var102 = "NULL, /* empty ("; +var103 = standard___standard__NativeString___to_s_with_length(var102, 16l); +var101 = var103; +varonce100 = var101; +} +((struct instance_standard__NativeArray*)var99)->values[0]=var101; +if (likely(varonce104!=NULL)) { +var105 = varonce104; +} else { +var106 = ": "; +var107 = standard___standard__NativeString___to_s_with_length(var106, 2l); +var105 = var107; +varonce104 = var105; +} +((struct instance_standard__NativeArray*)var99)->values[2]=var105; +if (likely(varonce108!=NULL)) { +var109 = varonce108; +} else { +var110 = " not a live type) */"; +var111 = standard___standard__NativeString___to_s_with_length(var110, 20l); +var109 = var111; +varonce108 = var109; +} +((struct instance_standard__NativeArray*)var99)->values[4]=var109; +} else { +var99 = varonce98; +varonce98 = NULL; +} +{ +var112 = ((val*(*)(val* self))(var_t->class->vft[COLOR_standard__string__Object__to_s]))(var_t); /* to_s on */ +} +((struct instance_standard__NativeArray*)var99)->values[1]=var112; +{ +var113 = ((val*(*)(val* self))(var_tv->class->vft[COLOR_standard__string__Object__to_s]))(var_tv); /* to_s on */ +} +((struct instance_standard__NativeArray*)var99)->values[3]=var113; +{ +var114 = ((val*(*)(val* self))(var99->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var99); /* native_to_s on */ +} +varonce98 = var99; +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var114); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} +} +{ +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_47); /* Direct call array#ArrayIterator#next on */ +} +} else { +goto BREAK_label; +} +} +BREAK_label: (void)0; +{ +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__finish(var_47); /* Direct call array#ArrayIterator#finish on */ +} +if (likely(varonce115!=NULL)) { +var116 = varonce115; +} else { +var117 = "}"; +var118 = standard___standard__NativeString___to_s_with_length(var117, 1l); +var116 = var118; +varonce115 = var116; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var116); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +if (likely(varonce119!=NULL)) { +var120 = varonce119; +} else { +var121 = "};"; +var122 = standard___standard__NativeString___to_s_with_length(var121, 2l); +var120 = var122; +varonce119 = var120; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var120); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +RET_LABEL:; +} /* method separate_compiler#SeparateCompiler#compile_class_to_c for (self: SeparateCompiler, MClass) */ void nit___nit__SeparateCompiler___compile_class_to_c(val* self, val* p0) { val* var_mclass /* var mclass: MClass */; @@ -9,1218 +547,1036 @@ val* var5 /* : MClassType */; val* var_mtype /* var mtype: MClassType */; val* var6 /* : String */; val* var_c_name /* var c_name: String */; -val* var7 /* : Map[MClass, Array[nullable MPropDef]] */; -val* var9 /* : Map[MClass, Array[nullable MPropDef]] */; -val* var10 /* : nullable Object */; -val* var_vft /* var vft: Array[nullable MPropDef] */; -val* var11 /* : Map[MClass, Array[nullable MPropDef]] */; -val* var13 /* : Map[MClass, Array[nullable MPropDef]] */; -val* var14 /* : nullable Object */; -val* var_attrs /* var attrs: Array[nullable MPropDef] */; -val* var15 /* : AbstractCompilerVisitor */; +val* var7 /* : AbstractCompilerVisitor */; val* var_v /* var v: SeparateCompilerVisitor */; -val* var16 /* : nullable RapidTypeAnalysis */; -val* var18 /* : nullable RapidTypeAnalysis */; +val* var8 /* : nullable RapidTypeAnalysis */; +val* var10 /* : nullable RapidTypeAnalysis */; val* var_rta /* var rta: nullable RapidTypeAnalysis */; +short int var11 /* : Bool */; +short int var12 /* : Bool */; +short int var13 /* : Bool */; +short int var14 /* : Bool */; +short int var15 /* : Bool */; +short int var16 /* : Bool */; +val* var_other /* var other: nullable Object */; +short int var18 /* : Bool */; short int var19 /* : Bool */; -short int var20 /* : Bool */; -short int var21 /* : Bool */; -short int var22 /* : Bool */; -val* var23 /* : null */; +short int var_ /* var : Bool */; +val* var20 /* : HashSet[MClass] */; +val* var22 /* : HashSet[MClass] */; +short int var23 /* : Bool */; short int var24 /* : Bool */; -short int var25 /* : Bool */; -val* var_other /* var other: nullable Object */; +short int var_25 /* var : Bool */; +short int var26 /* : Bool */; short int var27 /* : Bool */; -short int var28 /* : Bool */; -short int var_ /* var : Bool */; -val* var29 /* : HashSet[MClass] */; -val* var31 /* : HashSet[MClass] */; -short int var32 /* : Bool */; -short int var33 /* : Bool */; -short int var_34 /* var : Bool */; -val* var35 /* : String */; +short int var_28 /* var : Bool */; +val* var29 /* : String */; +val* var31 /* : String */; static val* varonce; -val* var36 /* : String */; -char* var37 /* : NativeString */; -long var38 /* : Int */; -val* var39 /* : FlatString */; -short int var40 /* : Bool */; -short int var_41 /* var : Bool */; +val* var32 /* : String */; +char* var33 /* : NativeString */; +val* var34 /* : FlatString */; +short int var35 /* : Bool */; +short int var37 /* : Bool */; +short int var38 /* : Bool */; +short int var_39 /* var : Bool */; +val* var40 /* : String */; val* var42 /* : String */; +static val* varonce43; val* var44 /* : String */; -static val* varonce45; -val* var46 /* : String */; -char* var47 /* : NativeString */; -long var48 /* : Int */; -val* var49 /* : FlatString */; +char* var45 /* : NativeString */; +val* var46 /* : FlatString */; +short int var47 /* : Bool */; +short int var49 /* : Bool */; short int var50 /* : Bool */; -short int var52 /* : Bool */; -short int var53 /* : Bool */; -short int var_54 /* var : Bool */; -val* var55 /* : String */; -val* var57 /* : String */; -static val* varonce58; -val* var59 /* : String */; -char* var60 /* : NativeString */; -long var61 /* : Int */; -val* var62 /* : FlatString */; -short int var63 /* : Bool */; -short int var65 /* : Bool */; -short int var66 /* : Bool */; short int var_is_dead /* var is_dead: Bool */; -static val* varonce67; -val* var68 /* : String */; -char* var69 /* : NativeString */; -long var70 /* : Int */; -val* var71 /* : FlatString */; -static val* varonce72; -val* var73 /* : String */; -char* var74 /* : NativeString */; -long var75 /* : Int */; -val* var76 /* : FlatString */; -val* var77 /* : Array[Object] */; -long var78 /* : Int */; -val* var79 /* : NativeArray[Object] */; -val* var80 /* : String */; -short int var81 /* : Bool */; -static val* varonce82; -val* var83 /* : String */; -char* var84 /* : NativeString */; -long var85 /* : Int */; -val* var86 /* : FlatString */; -val* var87 /* : Array[Object] */; -long var88 /* : Int */; -val* var89 /* : NativeArray[Object] */; -val* var90 /* : String */; -static val* varonce91; -val* var92 /* : String */; -char* var93 /* : NativeString */; -long var94 /* : Int */; -val* var95 /* : FlatString */; -static val* varonce96; -val* var97 /* : String */; -char* var98 /* : NativeString */; -long var99 /* : Int */; -val* var100 /* : FlatString */; -val* var101 /* : Array[Object] */; -long var102 /* : Int */; -val* var103 /* : NativeArray[Object] */; -val* var104 /* : String */; -static val* varonce105; -val* var106 /* : String */; -char* var107 /* : NativeString */; -long var108 /* : Int */; -val* var109 /* : FlatString */; -static val* varonce110; -val* var111 /* : String */; -char* var112 /* : NativeString */; -long var113 /* : Int */; -val* var114 /* : FlatString */; -val* var115 /* : Array[Object] */; -long var116 /* : Int */; -val* var117 /* : NativeArray[Object] */; -val* var118 /* : String */; -long var119 /* : Int */; -static val* varonce120; -val* var121 /* : String */; -char* var122 /* : NativeString */; -long var123 /* : Int */; -val* var124 /* : FlatString */; -val* var125 /* : Array[Object] */; -long var126 /* : Int */; -val* var127 /* : NativeArray[Object] */; -val* var128 /* : Object */; -val* var129 /* : String */; -static val* varonce130; -val* var131 /* : String */; -char* var132 /* : NativeString */; -long var133 /* : Int */; -val* var134 /* : FlatString */; -long var135 /* : Int */; +val* var52 /* : NativeArray[String] */; +static val* varonce51; +static val* varonce53; +val* var54 /* : String */; +char* var55 /* : NativeString */; +val* var56 /* : FlatString */; +static val* varonce57; +val* var58 /* : String */; +char* var59 /* : NativeString */; +val* var60 /* : FlatString */; +val* var61 /* : String */; +short int var62 /* : Bool */; +val* var64 /* : NativeArray[String] */; +static val* varonce63; +static val* varonce65; +val* var66 /* : String */; +char* var67 /* : NativeString */; +val* var68 /* : FlatString */; +val* var69 /* : String */; +val* var71 /* : NativeArray[String] */; +static val* varonce70; +static val* varonce72; +val* var73 /* : String */; +char* var74 /* : NativeString */; +val* var75 /* : FlatString */; +static val* varonce76; +val* var77 /* : String */; +char* var78 /* : NativeString */; +val* var79 /* : FlatString */; +val* var80 /* : String */; +val* var82 /* : NativeArray[String] */; +static val* varonce81; +static val* varonce83; +val* var84 /* : String */; +char* var85 /* : NativeString */; +val* var86 /* : FlatString */; +static val* varonce87; +val* var88 /* : String */; +char* var89 /* : NativeString */; +val* var90 /* : FlatString */; +val* var91 /* : String */; +val* var93 /* : NativeArray[String] */; +static val* varonce92; +static val* varonce94; +val* var95 /* : String */; +char* var96 /* : NativeString */; +val* var97 /* : FlatString */; +long var98 /* : Int */; +val* var99 /* : String */; +val* var100 /* : String */; +static val* varonce101; +val* var102 /* : String */; +char* var103 /* : NativeString */; +val* var104 /* : FlatString */; +val* var105 /* : Map[MClass, Array[nullable MPropDef]] */; +val* var107 /* : Map[MClass, Array[nullable MPropDef]] */; +val* var108 /* : nullable Object */; +val* var_vft /* var vft: nullable Array[nullable MPropDef] */; +short int var109 /* : Bool */; +short int var110 /* : Bool */; +short int var112 /* : Bool */; +short int var113 /* : Bool */; long var_i /* var i: Int */; -long var136 /* : Int */; -long var138 /* : Int */; -long var_139 /* var : Int */; -short int var140 /* : Bool */; -short int var142 /* : Bool */; +long var114 /* : Int */; +long var116 /* : Int */; +long var_117 /* var : Int */; +short int var118 /* : Bool */; +short int var120 /* : Bool */; int cltype; int idtype; const char* var_class_name; -short int var143 /* : Bool */; -val* var144 /* : nullable Object */; +short int var121 /* : Bool */; +val* var122 /* : nullable Object */; val* var_mpropdef /* var mpropdef: nullable MPropDef */; -val* var145 /* : null */; -short int var146 /* : Bool */; +short int var123 /* : Bool */; +short int var124 /* : Bool */; +val* var_other126 /* var other: nullable Object */; +short int var127 /* : Bool */; +short int var129 /* : Bool */; +static val* varonce130; +val* var131 /* : String */; +char* var132 /* : NativeString */; +val* var133 /* : FlatString */; +short int var134 /* : Bool */; +int cltype135; +int idtype136; +short int var137 /* : Bool */; +short int var138 /* : Bool */; +short int var139 /* : Bool */; +short int var141 /* : Bool */; +short int var142 /* : Bool */; +short int var_143 /* var : Bool */; +val* var144 /* : HashSet[MMethodDef] */; +val* var146 /* : HashSet[MMethodDef] */; short int var147 /* : Bool */; -val* var_other149 /* var other: nullable Object */; -short int var150 /* : Bool */; -short int var152 /* : Bool */; -static val* varonce153; -val* var154 /* : String */; -char* var155 /* : NativeString */; -long var156 /* : Int */; -val* var157 /* : FlatString */; -short int var158 /* : Bool */; -int cltype159; -int idtype160; -short int var161 /* : Bool */; -val* var162 /* : null */; -short int var163 /* : Bool */; -short int var164 /* : Bool */; -short int var166 /* : Bool */; -short int var167 /* : Bool */; -short int var_168 /* var : Bool */; -val* var169 /* : HashSet[MMethodDef] */; -val* var171 /* : HashSet[MMethodDef] */; -short int var172 /* : Bool */; -short int var173 /* : Bool */; -static val* varonce174; +short int var148 /* : Bool */; +val* var150 /* : NativeArray[String] */; +static val* varonce149; +static val* varonce151; +val* var152 /* : String */; +char* var153 /* : NativeString */; +val* var154 /* : FlatString */; +static val* varonce155; +val* var156 /* : String */; +char* var157 /* : NativeString */; +val* var158 /* : FlatString */; +static val* varonce159; +val* var160 /* : String */; +char* var161 /* : NativeString */; +val* var162 /* : FlatString */; +static val* varonce163; +val* var164 /* : String */; +char* var165 /* : NativeString */; +val* var166 /* : FlatString */; +val* var167 /* : MModule */; +val* var169 /* : MModule */; +val* var170 /* : String */; +val* var171 /* : String */; +val* var172 /* : String */; +val* var173 /* : String */; +val* var174 /* : SeparateRuntimeFunction */; +val* var_rf /* var rf: SeparateRuntimeFunction */; val* var175 /* : String */; -char* var176 /* : NativeString */; -long var177 /* : Int */; -val* var178 /* : FlatString */; -val* var179 /* : MModule */; -val* var181 /* : MModule */; +val* var177 /* : NativeArray[String] */; +static val* varonce176; +static val* varonce178; +val* var179 /* : String */; +char* var180 /* : NativeString */; +val* var181 /* : FlatString */; static val* varonce182; val* var183 /* : String */; char* var184 /* : NativeString */; -long var185 /* : Int */; -val* var186 /* : FlatString */; -static val* varonce187; -val* var188 /* : String */; -char* var189 /* : NativeString */; -long var190 /* : Int */; -val* var191 /* : FlatString */; -static val* varonce192; -val* var193 /* : String */; -char* var194 /* : NativeString */; -long var195 /* : Int */; -val* var196 /* : FlatString */; -val* var197 /* : Array[Object] */; -long var198 /* : Int */; -val* var199 /* : NativeArray[Object] */; -val* var200 /* : String */; -val* var201 /* : SeparateRuntimeFunction */; -val* var_rf /* var rf: SeparateRuntimeFunction */; +val* var185 /* : FlatString */; +static val* varonce186; +val* var187 /* : String */; +char* var188 /* : NativeString */; +val* var189 /* : FlatString */; +static val* varonce190; +val* var191 /* : String */; +char* var192 /* : NativeString */; +val* var193 /* : FlatString */; +static val* varonce194; +val* var195 /* : String */; +char* var196 /* : NativeString */; +val* var197 /* : FlatString */; +val* var198 /* : String */; +val* var199 /* : MModule */; +val* var201 /* : MModule */; val* var202 /* : String */; -static val* varonce203; +val* var203 /* : String */; val* var204 /* : String */; -char* var205 /* : NativeString */; +val* var205 /* : String */; long var206 /* : Int */; -val* var207 /* : FlatString */; -val* var208 /* : String */; -static val* varonce209; -val* var210 /* : String */; -char* var211 /* : NativeString */; -long var212 /* : Int */; -val* var213 /* : FlatString */; -val* var214 /* : MModule */; -val* var216 /* : MModule */; -static val* varonce217; -val* var218 /* : String */; -char* var219 /* : NativeString */; -long var220 /* : Int */; -val* var221 /* : FlatString */; -static val* varonce222; -val* var223 /* : String */; -char* var224 /* : NativeString */; -long var225 /* : Int */; -val* var226 /* : FlatString */; -static val* varonce227; -val* var228 /* : String */; -char* var229 /* : NativeString */; -long var230 /* : Int */; -val* var231 /* : FlatString */; -val* var232 /* : Array[Object] */; -long var233 /* : Int */; -val* var234 /* : NativeArray[Object] */; -val* var235 /* : String */; -long var236 /* : Int */; -long var237 /* : Int */; -static val* varonce239; -val* var240 /* : String */; -char* var241 /* : NativeString */; -long var242 /* : Int */; -val* var243 /* : FlatString */; -static val* varonce244; -val* var245 /* : String */; -char* var246 /* : NativeString */; -long var247 /* : Int */; -val* var248 /* : FlatString */; -short int var249 /* : Bool */; -val* var250 /* : String */; -static val* varonce251; -val* var252 /* : String */; -char* var253 /* : NativeString */; -long var254 /* : Int */; -val* var255 /* : FlatString */; -short int var256 /* : Bool */; -short int var258 /* : Bool */; -short int var259 /* : Bool */; -short int var_260 /* var : Bool */; -val* var261 /* : MClass */; -val* var263 /* : MClass */; -val* var264 /* : String */; -val* var266 /* : String */; -static val* varonce267; -val* var268 /* : String */; -char* var269 /* : NativeString */; -long var270 /* : Int */; -val* var271 /* : FlatString */; -short int var272 /* : Bool */; -val* var273 /* : CodeWriter */; -val* var275 /* : CodeWriter */; -static val* varonce276; -val* var277 /* : String */; -char* var278 /* : NativeString */; -long var279 /* : Int */; -val* var280 /* : FlatString */; -static val* varonce281; -val* var282 /* : String */; -char* var283 /* : NativeString */; -long var284 /* : Int */; -val* var285 /* : FlatString */; -val* var286 /* : Array[Object] */; -long var287 /* : Int */; -val* var288 /* : NativeArray[Object] */; +static val* varonce208; +val* var209 /* : String */; +char* var210 /* : NativeString */; +val* var211 /* : FlatString */; +static val* varonce212; +val* var213 /* : String */; +char* var214 /* : NativeString */; +val* var215 /* : FlatString */; +short int var216 /* : Bool */; +short int var217 /* : Bool */; +short int var_218 /* var : Bool */; +val* var219 /* : MClass */; +val* var221 /* : MClass */; +val* var222 /* : String */; +val* var224 /* : String */; +static val* varonce225; +val* var226 /* : String */; +char* var227 /* : NativeString */; +val* var228 /* : FlatString */; +short int var229 /* : Bool */; +short int var230 /* : Bool */; +short int var232 /* : Bool */; +val* var233 /* : CodeWriter */; +val* var235 /* : CodeWriter */; +val* var237 /* : NativeArray[String] */; +static val* varonce236; +static val* varonce238; +val* var239 /* : String */; +char* var240 /* : NativeString */; +val* var241 /* : FlatString */; +static val* varonce242; +val* var243 /* : String */; +char* var244 /* : NativeString */; +val* var245 /* : FlatString */; +val* var246 /* : String */; +val* var247 /* : CodeWriter */; +val* var249 /* : CodeWriter */; +static val* varonce250; +val* var251 /* : String */; +char* var252 /* : NativeString */; +val* var253 /* : FlatString */; +val* var254 /* : CodeWriter */; +val* var256 /* : CodeWriter */; +static val* varonce257; +val* var258 /* : String */; +char* var259 /* : NativeString */; +val* var260 /* : FlatString */; +val* var261 /* : CodeWriter */; +val* var263 /* : CodeWriter */; +val* var265 /* : NativeArray[String] */; +static val* varonce264; +static val* varonce266; +val* var267 /* : String */; +char* var268 /* : NativeString */; +val* var269 /* : FlatString */; +val* var270 /* : String */; +val* var271 /* : String */; +val* var272 /* : CodeWriter */; +val* var274 /* : CodeWriter */; +static val* varonce275; +val* var276 /* : String */; +char* var277 /* : NativeString */; +val* var278 /* : FlatString */; +short int var279 /* : Bool */; +val* var280 /* : HashSet[MClassType] */; +val* var282 /* : HashSet[MClassType] */; +short int var283 /* : Bool */; +short int var284 /* : Bool */; +short int var_285 /* var : Bool */; +val* var286 /* : MClass */; +val* var288 /* : MClass */; val* var289 /* : String */; -val* var290 /* : CodeWriter */; -val* var292 /* : CodeWriter */; -static val* varonce293; -val* var294 /* : String */; -char* var295 /* : NativeString */; -long var296 /* : Int */; -val* var297 /* : FlatString */; -val* var298 /* : CodeWriter */; -val* var300 /* : CodeWriter */; -static val* varonce301; -val* var302 /* : String */; -char* var303 /* : NativeString */; -long var304 /* : Int */; +val* var291 /* : String */; +static val* varonce292; +val* var293 /* : String */; +char* var294 /* : NativeString */; +val* var295 /* : FlatString */; +short int var296 /* : Bool */; +short int var298 /* : Bool */; +short int var299 /* : Bool */; +val* var301 /* : NativeArray[String] */; +static val* varonce300; +static val* varonce302; +val* var303 /* : String */; +char* var304 /* : NativeString */; val* var305 /* : FlatString */; -val* var306 /* : CodeWriter */; -val* var308 /* : CodeWriter */; -val* var309 /* : String */; -static val* varonce310; -val* var311 /* : String */; -char* var312 /* : NativeString */; -long var313 /* : Int */; -val* var314 /* : FlatString */; -val* var315 /* : Array[Object] */; -long var316 /* : Int */; -val* var317 /* : NativeArray[Object] */; +val* var306 /* : String */; +val* var308 /* : NativeArray[String] */; +static val* varonce307; +static val* varonce309; +val* var310 /* : String */; +char* var311 /* : NativeString */; +val* var312 /* : FlatString */; +static val* varonce313; +val* var314 /* : String */; +char* var315 /* : NativeString */; +val* var316 /* : FlatString */; +static val* varonce317; val* var318 /* : String */; -val* var319 /* : CodeWriter */; -val* var321 /* : CodeWriter */; -static val* varonce322; -val* var323 /* : String */; -char* var324 /* : NativeString */; -long var325 /* : Int */; -val* var326 /* : FlatString */; -short int var327 /* : Bool */; -val* var328 /* : HashSet[MClassType] */; -val* var330 /* : HashSet[MClassType] */; -short int var331 /* : Bool */; -short int var332 /* : Bool */; -short int var_333 /* var : Bool */; -val* var334 /* : MClass */; -val* var336 /* : MClass */; -val* var337 /* : String */; -val* var339 /* : String */; -static val* varonce340; -val* var341 /* : String */; -char* var342 /* : NativeString */; -long var343 /* : Int */; +char* var319 /* : NativeString */; +val* var320 /* : FlatString */; +val* var321 /* : String */; +val* var322 /* : String */; +val* var324 /* : NativeArray[String] */; +static val* varonce323; +static val* varonce325; +val* var326 /* : String */; +char* var327 /* : NativeString */; +val* var328 /* : FlatString */; +static val* varonce329; +val* var330 /* : String */; +char* var331 /* : NativeString */; +val* var332 /* : FlatString */; +val* var333 /* : String */; +val* var334 /* : String */; +val* var336 /* : NativeArray[String] */; +static val* varonce335; +static val* varonce337; +val* var338 /* : String */; +char* var339 /* : NativeString */; +val* var340 /* : FlatString */; +static val* varonce341; +val* var342 /* : String */; +char* var343 /* : NativeString */; val* var344 /* : FlatString */; -short int var345 /* : Bool */; -short int var347 /* : Bool */; -short int var348 /* : Bool */; -static val* varonce349; +static val* varonce345; +val* var346 /* : String */; +char* var347 /* : NativeString */; +val* var348 /* : FlatString */; +val* var349 /* : String */; val* var350 /* : String */; -char* var351 /* : NativeString */; -long var352 /* : Int */; -val* var353 /* : FlatString */; -val* var354 /* : Array[Object] */; -long var355 /* : Int */; -val* var356 /* : NativeArray[Object] */; -val* var357 /* : String */; +val* var351 /* : String */; +val* var353 /* : NativeArray[String] */; +static val* varonce352; +static val* varonce354; +val* var355 /* : String */; +char* var356 /* : NativeString */; +val* var357 /* : FlatString */; static val* varonce358; val* var359 /* : String */; char* var360 /* : NativeString */; -long var361 /* : Int */; -val* var362 /* : FlatString */; -static val* varonce363; -val* var364 /* : String */; -char* var365 /* : NativeString */; -long var366 /* : Int */; -val* var367 /* : FlatString */; -val* var368 /* : String */; -static val* varonce369; -val* var370 /* : String */; -char* var371 /* : NativeString */; -long var372 /* : Int */; -val* var373 /* : FlatString */; -val* var374 /* : Array[Object] */; -long var375 /* : Int */; -val* var376 /* : NativeArray[Object] */; -val* var377 /* : String */; -static val* varonce378; +val* var361 /* : FlatString */; +static val* varonce362; +val* var363 /* : String */; +char* var364 /* : NativeString */; +val* var365 /* : FlatString */; +val* var366 /* : String */; +val* var367 /* : AbstractCompiler */; +val* var369 /* : AbstractCompiler */; +val* var370 /* : Set[MType] */; +val* var372 /* : Set[MType] */; +val* var374 /* : NativeArray[String] */; +static val* varonce373; +static val* varonce375; +val* var376 /* : String */; +char* var377 /* : NativeString */; +val* var378 /* : FlatString */; val* var379 /* : String */; -char* var380 /* : NativeString */; -long var381 /* : Int */; -val* var382 /* : FlatString */; -static val* varonce383; -val* var384 /* : String */; -char* var385 /* : NativeString */; -long var386 /* : Int */; -val* var387 /* : FlatString */; -val* var388 /* : Array[Object] */; -long var389 /* : Int */; -val* var390 /* : NativeArray[Object] */; -val* var391 /* : String */; -static val* varonce392; -val* var393 /* : String */; -char* var394 /* : NativeString */; -long var395 /* : Int */; +val* var381 /* : NativeArray[String] */; +static val* varonce380; +static val* varonce382; +val* var383 /* : String */; +char* var384 /* : NativeString */; +val* var385 /* : FlatString */; +static val* varonce386; +val* var387 /* : String */; +char* var388 /* : NativeString */; +val* var389 /* : FlatString */; +val* var390 /* : String */; +val* var392 /* : NativeArray[String] */; +static val* varonce391; +static val* varonce393; +val* var394 /* : String */; +char* var395 /* : NativeString */; val* var396 /* : FlatString */; val* var397 /* : String */; +val* var399 /* : NativeArray[String] */; static val* varonce398; -val* var399 /* : String */; -char* var400 /* : NativeString */; -long var401 /* : Int */; -val* var402 /* : FlatString */; -val* var403 /* : String */; +static val* varonce400; +val* var401 /* : String */; +char* var402 /* : NativeString */; +val* var403 /* : FlatString */; static val* varonce404; val* var405 /* : String */; char* var406 /* : NativeString */; -long var407 /* : Int */; -val* var408 /* : FlatString */; -val* var409 /* : Array[Object] */; -long var410 /* : Int */; -val* var411 /* : NativeArray[Object] */; -val* var412 /* : String */; +val* var407 /* : FlatString */; +val* var408 /* : String */; +static val* varonce409; +val* var410 /* : String */; +char* var411 /* : NativeString */; +val* var412 /* : FlatString */; static val* varonce413; val* var414 /* : String */; char* var415 /* : NativeString */; -long var416 /* : Int */; -val* var417 /* : FlatString */; -static val* varonce418; -val* var419 /* : String */; -char* var420 /* : NativeString */; -long var421 /* : Int */; -val* var422 /* : FlatString */; -static val* varonce423; +val* var416 /* : FlatString */; +static val* varonce417; +val* var418 /* : String */; +char* var419 /* : NativeString */; +val* var420 /* : FlatString */; +val* var421 /* : MClass */; +val* var423 /* : MClass */; val* var424 /* : String */; -char* var425 /* : NativeString */; -long var426 /* : Int */; -val* var427 /* : FlatString */; -val* var428 /* : Array[Object] */; -long var429 /* : Int */; -val* var430 /* : NativeArray[Object] */; -val* var431 /* : String */; -val* var432 /* : AbstractCompiler */; -val* var434 /* : AbstractCompiler */; -val* var435 /* : Set[MType] */; -val* var437 /* : Set[MType] */; +val* var426 /* : String */; +static val* varonce427; +val* var428 /* : String */; +char* var429 /* : NativeString */; +val* var430 /* : FlatString */; +short int var431 /* : Bool */; +short int var433 /* : Bool */; +short int var434 /* : Bool */; +val* var435 /* : AbstractCompilerVisitor */; +val* var437 /* : NativeArray[String] */; +static val* varonce436; static val* varonce438; val* var439 /* : String */; char* var440 /* : NativeString */; -long var441 /* : Int */; -val* var442 /* : FlatString */; -val* var443 /* : Array[Object] */; -long var444 /* : Int */; -val* var445 /* : NativeArray[Object] */; +val* var441 /* : FlatString */; +val* var442 /* : String */; +val* var444 /* : NativeArray[String] */; +static val* varonce443; +static val* varonce445; val* var446 /* : String */; -static val* varonce447; -val* var448 /* : String */; -char* var449 /* : NativeString */; -long var450 /* : Int */; -val* var451 /* : FlatString */; -static val* varonce452; +char* var447 /* : NativeString */; +val* var448 /* : FlatString */; +static val* varonce449; +val* var450 /* : String */; +char* var451 /* : NativeString */; +val* var452 /* : FlatString */; val* var453 /* : String */; -char* var454 /* : NativeString */; -long var455 /* : Int */; -val* var456 /* : FlatString */; -val* var457 /* : Array[Object] */; -long var458 /* : Int */; -val* var459 /* : NativeArray[Object] */; -val* var460 /* : String */; +val* var454 /* : String */; +val* var456 /* : NativeArray[String] */; +static val* varonce455; +static val* varonce457; +val* var458 /* : String */; +char* var459 /* : NativeString */; +val* var460 /* : FlatString */; static val* varonce461; val* var462 /* : String */; char* var463 /* : NativeString */; -long var464 /* : Int */; -val* var465 /* : FlatString */; -val* var466 /* : Array[Object] */; -long var467 /* : Int */; -val* var468 /* : NativeArray[Object] */; -val* var469 /* : String */; -static val* varonce470; -val* var471 /* : String */; -char* var472 /* : NativeString */; -long var473 /* : Int */; -val* var474 /* : FlatString */; -static val* varonce475; -val* var476 /* : String */; -char* var477 /* : NativeString */; -long var478 /* : Int */; -val* var479 /* : FlatString */; -val* var480 /* : Array[Object] */; -long var481 /* : Int */; -val* var482 /* : NativeArray[Object] */; -val* var483 /* : String */; -static val* varonce484; +val* var464 /* : FlatString */; +val* var465 /* : String */; +val* var466 /* : String */; +val* var468 /* : NativeArray[String] */; +static val* varonce467; +static val* varonce469; +val* var470 /* : String */; +char* var471 /* : NativeString */; +val* var472 /* : FlatString */; +static val* varonce473; +val* var474 /* : String */; +char* var475 /* : NativeString */; +val* var476 /* : FlatString */; +val* var477 /* : String */; +val* var478 /* : String */; +val* var480 /* : NativeArray[String] */; +static val* varonce479; +static val* varonce481; +val* var482 /* : String */; +char* var483 /* : NativeString */; +val* var484 /* : FlatString */; val* var485 /* : String */; -char* var486 /* : NativeString */; -long var487 /* : Int */; -val* var488 /* : FlatString */; -static val* varonce489; -val* var490 /* : String */; -char* var491 /* : NativeString */; -long var492 /* : Int */; -val* var493 /* : FlatString */; -static val* varonce494; -val* var495 /* : String */; -char* var496 /* : NativeString */; -long var497 /* : Int */; +val* var486 /* : String */; +static val* varonce487; +val* var488 /* : String */; +char* var489 /* : NativeString */; +val* var490 /* : FlatString */; +val* var491 /* : RuntimeVariable */; +val* var_res /* var res: RuntimeVariable */; +val* var494 /* : NativeArray[String] */; +static val* varonce493; +static val* varonce495; +val* var496 /* : String */; +char* var497 /* : NativeString */; val* var498 /* : FlatString */; -val* var499 /* : MClass */; -val* var501 /* : MClass */; -val* var502 /* : String */; +static val* varonce499; +val* var500 /* : String */; +char* var501 /* : NativeString */; +val* var502 /* : FlatString */; +val* var503 /* : String */; val* var504 /* : String */; -static val* varonce505; -val* var506 /* : String */; -char* var507 /* : NativeString */; -long var508 /* : Int */; -val* var509 /* : FlatString */; -short int var510 /* : Bool */; -short int var512 /* : Bool */; -short int var513 /* : Bool */; -val* var514 /* : AbstractCompilerVisitor */; -static val* varonce515; -val* var516 /* : String */; -char* var517 /* : NativeString */; -long var518 /* : Int */; -val* var519 /* : FlatString */; -val* var520 /* : Array[Object] */; -long var521 /* : Int */; -val* var522 /* : NativeArray[Object] */; -val* var523 /* : String */; +val* var505 /* : String */; +val* var507 /* : NativeArray[String] */; +static val* varonce506; +static val* varonce508; +val* var509 /* : String */; +char* var510 /* : NativeString */; +val* var511 /* : FlatString */; +val* var512 /* : String */; +val* var513 /* : String */; +static val* varonce514; +val* var515 /* : String */; +char* var516 /* : NativeString */; +val* var517 /* : FlatString */; +val* var519 /* : NativeArray[String] */; +static val* varonce518; +static val* varonce520; +val* var521 /* : String */; +char* var522 /* : NativeString */; +val* var523 /* : FlatString */; val* var524 /* : String */; +val* var526 /* : NativeArray[String] */; static val* varonce525; -val* var526 /* : String */; -char* var527 /* : NativeString */; -long var528 /* : Int */; -val* var529 /* : FlatString */; -static val* varonce530; -val* var531 /* : String */; -char* var532 /* : NativeString */; -long var533 /* : Int */; +static val* varonce527; +val* var528 /* : String */; +char* var529 /* : NativeString */; +val* var530 /* : FlatString */; +static val* varonce531; +val* var532 /* : String */; +char* var533 /* : NativeString */; val* var534 /* : FlatString */; -val* var535 /* : Array[Object] */; -long var536 /* : Int */; -val* var537 /* : NativeArray[Object] */; -val* var538 /* : String */; +val* var535 /* : String */; +val* var536 /* : String */; +val* var538 /* : NativeArray[String] */; +static val* varonce537; static val* varonce539; val* var540 /* : String */; char* var541 /* : NativeString */; -long var542 /* : Int */; -val* var543 /* : FlatString */; -static val* varonce544; -val* var545 /* : String */; -char* var546 /* : NativeString */; -long var547 /* : Int */; -val* var548 /* : FlatString */; -val* var549 /* : Array[Object] */; -long var550 /* : Int */; -val* var551 /* : NativeArray[Object] */; +val* var542 /* : FlatString */; +static val* varonce543; +val* var544 /* : String */; +char* var545 /* : NativeString */; +val* var546 /* : FlatString */; +static val* varonce547; +val* var548 /* : String */; +char* var549 /* : NativeString */; +val* var550 /* : FlatString */; +val* var551 /* : String */; val* var552 /* : String */; val* var553 /* : String */; +val* var555 /* : NativeArray[String] */; static val* varonce554; -val* var555 /* : String */; -char* var556 /* : NativeString */; -long var557 /* : Int */; -val* var558 /* : FlatString */; -static val* varonce559; -val* var560 /* : String */; -char* var561 /* : NativeString */; -long var562 /* : Int */; +static val* varonce556; +val* var557 /* : String */; +char* var558 /* : NativeString */; +val* var559 /* : FlatString */; +static val* varonce560; +val* var561 /* : String */; +char* var562 /* : NativeString */; val* var563 /* : FlatString */; -val* var564 /* : Array[Object] */; -long var565 /* : Int */; -val* var566 /* : NativeArray[Object] */; +val* var564 /* : String */; +val* var565 /* : String */; +static val* varonce566; val* var567 /* : String */; -static val* varonce568; -val* var569 /* : String */; -char* var570 /* : NativeString */; -long var571 /* : Int */; -val* var572 /* : FlatString */; -val* var573 /* : Array[Object] */; -long var574 /* : Int */; -val* var575 /* : NativeArray[Object] */; -val* var576 /* : String */; -static val* varonce577; -val* var578 /* : String */; -char* var579 /* : NativeString */; -long var580 /* : Int */; -val* var581 /* : FlatString */; -val* var582 /* : RuntimeVariable */; -val* var_res /* var res: RuntimeVariable */; -short int var583 /* : Bool */; -static val* varonce585; -val* var586 /* : String */; -char* var587 /* : NativeString */; -long var588 /* : Int */; -val* var589 /* : FlatString */; -val* var590 /* : String */; -static val* varonce591; -val* var592 /* : String */; -char* var593 /* : NativeString */; -long var594 /* : Int */; -val* var595 /* : FlatString */; -val* var596 /* : Array[Object] */; -long var597 /* : Int */; -val* var598 /* : NativeArray[Object] */; -val* var599 /* : String */; -static val* varonce600; -val* var601 /* : String */; -char* var602 /* : NativeString */; -long var603 /* : Int */; -val* var604 /* : FlatString */; -val* var605 /* : Array[Object] */; -long var606 /* : Int */; -val* var607 /* : NativeArray[Object] */; -val* var608 /* : String */; +char* var568 /* : NativeString */; +val* var569 /* : FlatString */; +val* var570 /* : String */; +val* var572 /* : String */; +static val* varonce573; +val* var574 /* : String */; +char* var575 /* : NativeString */; +val* var576 /* : FlatString */; +short int var577 /* : Bool */; +val* var578 /* : CodeWriter */; +val* var580 /* : CodeWriter */; +val* var582 /* : NativeArray[String] */; +static val* varonce581; +static val* varonce583; +val* var584 /* : String */; +char* var585 /* : NativeString */; +val* var586 /* : FlatString */; +static val* varonce587; +val* var588 /* : String */; +char* var589 /* : NativeString */; +val* var590 /* : FlatString */; +val* var591 /* : String */; +val* var592 /* : CodeWriter */; +val* var594 /* : CodeWriter */; +static val* varonce595; +val* var596 /* : String */; +char* var597 /* : NativeString */; +val* var598 /* : FlatString */; +val* var599 /* : CodeWriter */; +val* var601 /* : CodeWriter */; +static val* varonce602; +val* var603 /* : String */; +char* var604 /* : NativeString */; +val* var605 /* : FlatString */; +val* var606 /* : CodeWriter */; +val* var608 /* : CodeWriter */; static val* varonce609; val* var610 /* : String */; char* var611 /* : NativeString */; -long var612 /* : Int */; -val* var613 /* : FlatString */; -static val* varonce614; -val* var615 /* : String */; -char* var616 /* : NativeString */; -long var617 /* : Int */; -val* var618 /* : FlatString */; -val* var619 /* : Array[Object] */; -long var620 /* : Int */; -val* var621 /* : NativeArray[Object] */; -val* var622 /* : String */; +val* var612 /* : FlatString */; +val* var613 /* : CodeWriter */; +val* var615 /* : CodeWriter */; +static val* varonce616; +val* var617 /* : String */; +char* var618 /* : NativeString */; +val* var619 /* : FlatString */; +val* var620 /* : CodeWriter */; +val* var622 /* : CodeWriter */; static val* varonce623; val* var624 /* : String */; char* var625 /* : NativeString */; -long var626 /* : Int */; -val* var627 /* : FlatString */; -static val* varonce628; -val* var629 /* : String */; -char* var630 /* : NativeString */; -long var631 /* : Int */; +val* var626 /* : FlatString */; +val* var628 /* : NativeArray[String] */; +static val* varonce627; +static val* varonce629; +val* var630 /* : String */; +char* var631 /* : NativeString */; val* var632 /* : FlatString */; -val* var633 /* : Array[Object] */; -long var634 /* : Int */; -val* var635 /* : NativeArray[Object] */; -val* var636 /* : String */; -static val* varonce637; -val* var638 /* : String */; -char* var639 /* : NativeString */; -long var640 /* : Int */; -val* var641 /* : FlatString */; -val* var642 /* : String */; -static val* varonce643; +val* var633 /* : String */; +val* var635 /* : NativeArray[String] */; +static val* varonce634; +static val* varonce636; +val* var637 /* : String */; +char* var638 /* : NativeString */; +val* var639 /* : FlatString */; +static val* varonce640; +val* var641 /* : String */; +char* var642 /* : NativeString */; +val* var643 /* : FlatString */; val* var644 /* : String */; -char* var645 /* : NativeString */; -long var646 /* : Int */; -val* var647 /* : FlatString */; +val* var645 /* : String */; +val* var647 /* : NativeArray[String] */; +static val* varonce646; static val* varonce648; val* var649 /* : String */; char* var650 /* : NativeString */; -long var651 /* : Int */; -val* var652 /* : FlatString */; -val* var653 /* : Array[Object] */; -long var654 /* : Int */; -val* var655 /* : NativeArray[Object] */; +val* var651 /* : FlatString */; +static val* varonce652; +val* var653 /* : String */; +char* var654 /* : NativeString */; +val* var655 /* : FlatString */; val* var656 /* : String */; -static val* varonce657; -val* var658 /* : String */; -char* var659 /* : NativeString */; -long var660 /* : Int */; -val* var661 /* : FlatString */; -static val* varonce662; -val* var663 /* : String */; -char* var664 /* : NativeString */; -long var665 /* : Int */; -val* var666 /* : FlatString */; -val* var667 /* : Array[Object] */; -long var668 /* : Int */; -val* var669 /* : NativeArray[Object] */; -val* var670 /* : String */; -static val* varonce671; -val* var672 /* : String */; -char* var673 /* : NativeString */; -long var674 /* : Int */; -val* var675 /* : FlatString */; -val* var676 /* : String */; -val* var678 /* : String */; -static val* varonce679; -val* var680 /* : String */; -char* var681 /* : NativeString */; -long var682 /* : Int */; -val* var683 /* : FlatString */; -short int var684 /* : Bool */; -val* var685 /* : CodeWriter */; -val* var687 /* : CodeWriter */; -static val* varonce688; -val* var689 /* : String */; -char* var690 /* : NativeString */; -long var691 /* : Int */; -val* var692 /* : FlatString */; +val* var657 /* : String */; +val* var659 /* : NativeArray[String] */; +static val* varonce658; +static val* varonce660; +val* var661 /* : String */; +char* var662 /* : NativeString */; +val* var663 /* : FlatString */; +static val* varonce664; +val* var665 /* : String */; +char* var666 /* : NativeString */; +val* var667 /* : FlatString */; +val* var668 /* : String */; +val* var669 /* : String */; +static val* varonce670; +val* var671 /* : String */; +char* var672 /* : NativeString */; +val* var673 /* : FlatString */; +val* var674 /* : String */; +val* var_res675 /* var res: String */; +val* var677 /* : NativeArray[String] */; +static val* varonce676; +static val* varonce678; +val* var679 /* : String */; +char* var680 /* : NativeString */; +val* var681 /* : FlatString */; +static val* varonce682; +val* var683 /* : String */; +char* var684 /* : NativeString */; +val* var685 /* : FlatString */; +static val* varonce686; +val* var687 /* : String */; +char* var688 /* : NativeString */; +val* var689 /* : FlatString */; +val* var690 /* : String */; +val* var691 /* : Array[MType] */; +val* var692 /* : nullable Object */; +val* var_mtype_elt /* var mtype_elt: MType */; +val* var694 /* : NativeArray[String] */; static val* varonce693; -val* var694 /* : String */; -char* var695 /* : NativeString */; -long var696 /* : Int */; -val* var697 /* : FlatString */; -val* var698 /* : Array[Object] */; -long var699 /* : Int */; -val* var700 /* : NativeArray[Object] */; -val* var701 /* : String */; -val* var702 /* : CodeWriter */; -val* var704 /* : CodeWriter */; -static val* varonce705; -val* var706 /* : String */; -char* var707 /* : NativeString */; -long var708 /* : Int */; -val* var709 /* : FlatString */; -val* var710 /* : CodeWriter */; -val* var712 /* : CodeWriter */; -static val* varonce713; -val* var714 /* : String */; -char* var715 /* : NativeString */; -long var716 /* : Int */; -val* var717 /* : FlatString */; -val* var718 /* : CodeWriter */; -val* var720 /* : CodeWriter */; -static val* varonce721; -val* var722 /* : String */; -char* var723 /* : NativeString */; -long var724 /* : Int */; +static val* varonce695; +val* var696 /* : String */; +char* var697 /* : NativeString */; +val* var698 /* : FlatString */; +static val* varonce699; +val* var700 /* : String */; +char* var701 /* : NativeString */; +val* var702 /* : FlatString */; +static val* varonce703; +val* var704 /* : String */; +char* var705 /* : NativeString */; +val* var706 /* : FlatString */; +val* var707 /* : String */; +val* var708 /* : String */; +val* var710 /* : NativeArray[String] */; +static val* varonce709; +static val* varonce711; +val* var712 /* : String */; +char* var713 /* : NativeString */; +val* var714 /* : FlatString */; +val* var715 /* : String */; +static val* varonce716; +val* var717 /* : String */; +char* var718 /* : NativeString */; +val* var719 /* : FlatString */; +val* var721 /* : NativeArray[String] */; +static val* varonce720; +static val* varonce722; +val* var723 /* : String */; +char* var724 /* : NativeString */; val* var725 /* : FlatString */; -val* var726 /* : CodeWriter */; -val* var728 /* : CodeWriter */; +val* var726 /* : String */; +val* var728 /* : NativeArray[String] */; +static val* varonce727; static val* varonce729; val* var730 /* : String */; char* var731 /* : NativeString */; -long var732 /* : Int */; -val* var733 /* : FlatString */; -val* var734 /* : CodeWriter */; -val* var736 /* : CodeWriter */; -static val* varonce737; -val* var738 /* : String */; -char* var739 /* : NativeString */; -long var740 /* : Int */; -val* var741 /* : FlatString */; -static val* varonce742; -val* var743 /* : String */; -char* var744 /* : NativeString */; -long var745 /* : Int */; -val* var746 /* : FlatString */; -val* var747 /* : Array[Object] */; -long var748 /* : Int */; -val* var749 /* : NativeArray[Object] */; -val* var750 /* : String */; -val* var751 /* : String */; -static val* varonce752; -val* var753 /* : String */; -char* var754 /* : NativeString */; -long var755 /* : Int */; -val* var756 /* : FlatString */; -static val* varonce757; -val* var758 /* : String */; -char* var759 /* : NativeString */; -long var760 /* : Int */; -val* var761 /* : FlatString */; -val* var762 /* : Array[Object] */; -long var763 /* : Int */; -val* var764 /* : NativeArray[Object] */; -val* var765 /* : String */; -static val* varonce766; -val* var767 /* : String */; -char* var768 /* : NativeString */; -long var769 /* : Int */; -val* var770 /* : FlatString */; -static val* varonce771; -val* var772 /* : String */; -char* var773 /* : NativeString */; -long var774 /* : Int */; -val* var775 /* : FlatString */; -val* var776 /* : Array[Object] */; -long var777 /* : Int */; -val* var778 /* : NativeArray[Object] */; -val* var779 /* : String */; +val* var732 /* : FlatString */; +static val* varonce733; +val* var734 /* : String */; +char* var735 /* : NativeString */; +val* var736 /* : FlatString */; +val* var737 /* : String */; +val* var739 /* : NativeArray[String] */; +static val* varonce738; +static val* varonce740; +val* var741 /* : String */; +char* var742 /* : NativeString */; +val* var743 /* : FlatString */; +val* var744 /* : String */; +val* var746 /* : NativeArray[String] */; +static val* varonce745; +static val* varonce747; +val* var748 /* : String */; +char* var749 /* : NativeString */; +val* var750 /* : FlatString */; +static val* varonce751; +val* var752 /* : String */; +char* var753 /* : NativeString */; +val* var754 /* : FlatString */; +val* var755 /* : String */; +static val* varonce756; +val* var757 /* : String */; +char* var758 /* : NativeString */; +val* var759 /* : FlatString */; +short int var760 /* : Bool */; +val* var761 /* : MClass */; +val* var763 /* : MClass */; +val* var764 /* : MClassKind */; +val* var766 /* : MClassKind */; +val* var767 /* : Sys */; +val* var768 /* : MClassKind */; +short int var769 /* : Bool */; +short int var771 /* : Bool */; +short int var773 /* : Bool */; +short int var_774 /* var : Bool */; +val* var775 /* : MClass */; +val* var777 /* : MClass */; +val* var778 /* : String */; val* var780 /* : String */; static val* varonce781; val* var782 /* : String */; char* var783 /* : NativeString */; -long var784 /* : Int */; -val* var785 /* : FlatString */; -static val* varonce786; -val* var787 /* : String */; -char* var788 /* : NativeString */; -long var789 /* : Int */; -val* var790 /* : FlatString */; -val* var791 /* : Array[Object] */; -long var792 /* : Int */; -val* var793 /* : NativeArray[Object] */; -val* var794 /* : String */; +val* var784 /* : FlatString */; +short int var785 /* : Bool */; +short int var787 /* : Bool */; +short int var788 /* : Bool */; +val* var789 /* : MModule */; +val* var791 /* : MModule */; +val* var792 /* : MClassType */; +val* var_pointer_type /* var pointer_type: MClassType */; +val* var794 /* : NativeArray[String] */; +static val* varonce793; static val* varonce795; val* var796 /* : String */; char* var797 /* : NativeString */; -long var798 /* : Int */; -val* var799 /* : FlatString */; -val* var800 /* : String */; -val* var_res801 /* var res: String */; +val* var798 /* : FlatString */; +val* var799 /* : String */; +val* var801 /* : NativeArray[String] */; +static val* varonce800; static val* varonce802; val* var803 /* : String */; char* var804 /* : NativeString */; -long var805 /* : Int */; -val* var806 /* : FlatString */; -static val* varonce807; -val* var808 /* : String */; -char* var809 /* : NativeString */; -long var810 /* : Int */; -val* var811 /* : FlatString */; +val* var805 /* : FlatString */; +static val* varonce806; +val* var807 /* : String */; +char* var808 /* : NativeString */; +val* var809 /* : FlatString */; +val* var810 /* : String */; +val* var811 /* : String */; +val* var813 /* : NativeArray[String] */; static val* varonce812; -val* var813 /* : String */; -char* var814 /* : NativeString */; -long var815 /* : Int */; -val* var816 /* : FlatString */; -val* var817 /* : Array[Object] */; -long var818 /* : Int */; -val* var819 /* : NativeArray[Object] */; -val* var820 /* : String */; -val* var821 /* : Array[MType] */; -val* var822 /* : nullable Object */; -val* var_mtype_elt /* var mtype_elt: MType */; -static val* varonce823; -val* var824 /* : String */; -char* var825 /* : NativeString */; -long var826 /* : Int */; -val* var827 /* : FlatString */; -static val* varonce828; -val* var829 /* : String */; -char* var830 /* : NativeString */; -long var831 /* : Int */; -val* var832 /* : FlatString */; -val* var833 /* : String */; -static val* varonce834; +static val* varonce814; +val* var815 /* : String */; +char* var816 /* : NativeString */; +val* var817 /* : FlatString */; +static val* varonce818; +val* var819 /* : String */; +char* var820 /* : NativeString */; +val* var821 /* : FlatString */; +val* var822 /* : String */; +val* var823 /* : String */; +val* var825 /* : NativeArray[String] */; +static val* varonce824; +static val* varonce826; +val* var827 /* : String */; +char* var828 /* : NativeString */; +val* var829 /* : FlatString */; +static val* varonce830; +val* var831 /* : String */; +char* var832 /* : NativeString */; +val* var833 /* : FlatString */; +val* var834 /* : String */; val* var835 /* : String */; -char* var836 /* : NativeString */; -long var837 /* : Int */; -val* var838 /* : FlatString */; -val* var839 /* : Array[Object] */; -long var840 /* : Int */; -val* var841 /* : NativeArray[Object] */; +val* var837 /* : NativeArray[String] */; +static val* varonce836; +static val* varonce838; +val* var839 /* : String */; +char* var840 /* : NativeString */; +val* var841 /* : FlatString */; val* var842 /* : String */; -static val* varonce843; -val* var844 /* : String */; -char* var845 /* : NativeString */; -long var846 /* : Int */; +val* var843 /* : String */; +static val* varonce844; +val* var845 /* : String */; +char* var846 /* : NativeString */; val* var847 /* : FlatString */; -val* var848 /* : Array[Object] */; -long var849 /* : Int */; -val* var850 /* : NativeArray[Object] */; -val* var851 /* : String */; -static val* varonce852; -val* var853 /* : String */; -char* var854 /* : NativeString */; -long var855 /* : Int */; +val* var848 /* : RuntimeVariable */; +val* var_res849 /* var res: RuntimeVariable */; +val* var852 /* : NativeArray[String] */; +static val* varonce851; +static val* varonce853; +val* var854 /* : String */; +char* var855 /* : NativeString */; val* var856 /* : FlatString */; static val* varonce857; val* var858 /* : String */; char* var859 /* : NativeString */; -long var860 /* : Int */; -val* var861 /* : FlatString */; -val* var862 /* : Array[Object] */; -long var863 /* : Int */; -val* var864 /* : NativeArray[Object] */; -val* var865 /* : String */; +val* var860 /* : FlatString */; +val* var861 /* : String */; +val* var862 /* : String */; +val* var863 /* : String */; +val* var865 /* : NativeArray[String] */; +static val* varonce864; static val* varonce866; val* var867 /* : String */; char* var868 /* : NativeString */; -long var869 /* : Int */; -val* var870 /* : FlatString */; -static val* varonce871; -val* var872 /* : String */; -char* var873 /* : NativeString */; -long var874 /* : Int */; +val* var869 /* : FlatString */; +val* var870 /* : String */; +val* var871 /* : String */; +static val* varonce872; +val* var873 /* : String */; +char* var874 /* : NativeString */; val* var875 /* : FlatString */; -val* var876 /* : Array[Object] */; -long var877 /* : Int */; -val* var878 /* : NativeArray[Object] */; +val* var877 /* : NativeArray[String] */; +static val* varonce876; +static val* varonce878; val* var879 /* : String */; -static val* varonce880; -val* var881 /* : String */; -char* var882 /* : NativeString */; -long var883 /* : Int */; -val* var884 /* : FlatString */; -val* var885 /* : Array[Object] */; -long var886 /* : Int */; -val* var887 /* : NativeArray[Object] */; -val* var888 /* : String */; +char* var880 /* : NativeString */; +val* var881 /* : FlatString */; +val* var882 /* : String */; +val* var884 /* : NativeArray[String] */; +static val* varonce883; +static val* varonce885; +val* var886 /* : String */; +char* var887 /* : NativeString */; +val* var888 /* : FlatString */; static val* varonce889; val* var890 /* : String */; char* var891 /* : NativeString */; -long var892 /* : Int */; -val* var893 /* : FlatString */; -static val* varonce894; -val* var895 /* : String */; -char* var896 /* : NativeString */; -long var897 /* : Int */; -val* var898 /* : FlatString */; -val* var899 /* : Array[Object] */; -long var900 /* : Int */; -val* var901 /* : NativeArray[Object] */; +val* var892 /* : FlatString */; +val* var893 /* : String */; +val* var894 /* : String */; +val* var896 /* : NativeArray[String] */; +static val* varonce895; +static val* varonce897; +val* var898 /* : String */; +char* var899 /* : NativeString */; +val* var900 /* : FlatString */; +static val* varonce901; val* var902 /* : String */; -static val* varonce903; -val* var904 /* : String */; -char* var905 /* : NativeString */; -long var906 /* : Int */; -val* var907 /* : FlatString */; -short int var908 /* : Bool */; -val* var909 /* : MClass */; -val* var911 /* : MClass */; -val* var912 /* : MClassKind */; -val* var914 /* : MClassKind */; -val* var915 /* : MClassKind */; -short int var916 /* : Bool */; -short int var918 /* : Bool */; -short int var920 /* : Bool */; -short int var_921 /* var : Bool */; -val* var922 /* : MClass */; -val* var924 /* : MClass */; +char* var903 /* : NativeString */; +val* var904 /* : FlatString */; +static val* varonce905; +val* var906 /* : String */; +char* var907 /* : NativeString */; +val* var908 /* : FlatString */; +val* var909 /* : String */; +val* var910 /* : String */; +val* var911 /* : String */; +val* var913 /* : NativeArray[String] */; +static val* varonce912; +static val* varonce914; +val* var915 /* : String */; +char* var916 /* : NativeString */; +val* var917 /* : FlatString */; +static val* varonce918; +val* var919 /* : String */; +char* var920 /* : NativeString */; +val* var921 /* : FlatString */; +val* var922 /* : String */; +val* var923 /* : String */; +static val* varonce924; val* var925 /* : String */; -val* var927 /* : String */; +char* var926 /* : NativeString */; +val* var927 /* : FlatString */; +val* var929 /* : NativeArray[String] */; static val* varonce928; -val* var929 /* : String */; -char* var930 /* : NativeString */; -long var931 /* : Int */; -val* var932 /* : FlatString */; -short int var933 /* : Bool */; -short int var935 /* : Bool */; -short int var936 /* : Bool */; -val* var937 /* : MModule */; -val* var939 /* : MModule */; -val* var940 /* : MClassType */; -val* var_pointer_type /* var pointer_type: MClassType */; +static val* varonce930; +val* var931 /* : String */; +char* var932 /* : NativeString */; +val* var933 /* : FlatString */; +val* var934 /* : String */; +val* var936 /* : NativeArray[String] */; +static val* varonce935; +static val* varonce937; +val* var938 /* : String */; +char* var939 /* : NativeString */; +val* var940 /* : FlatString */; static val* varonce941; val* var942 /* : String */; char* var943 /* : NativeString */; -long var944 /* : Int */; -val* var945 /* : FlatString */; -val* var946 /* : Array[Object] */; -long var947 /* : Int */; -val* var948 /* : NativeArray[Object] */; -val* var949 /* : String */; +val* var944 /* : FlatString */; +val* var945 /* : String */; +val* var946 /* : String */; +val* var948 /* : NativeArray[String] */; +static val* varonce947; +static val* varonce949; val* var950 /* : String */; -static val* varonce951; -val* var952 /* : String */; -char* var953 /* : NativeString */; -long var954 /* : Int */; -val* var955 /* : FlatString */; -static val* varonce956; +char* var951 /* : NativeString */; +val* var952 /* : FlatString */; +static val* varonce953; +val* var954 /* : String */; +char* var955 /* : NativeString */; +val* var956 /* : FlatString */; val* var957 /* : String */; -char* var958 /* : NativeString */; -long var959 /* : Int */; -val* var960 /* : FlatString */; -val* var961 /* : Array[Object] */; -long var962 /* : Int */; -val* var963 /* : NativeArray[Object] */; -val* var964 /* : String */; +val* var958 /* : String */; +val* var960 /* : NativeArray[String] */; +static val* varonce959; +static val* varonce961; +val* var962 /* : String */; +char* var963 /* : NativeString */; +val* var964 /* : FlatString */; static val* varonce965; val* var966 /* : String */; char* var967 /* : NativeString */; -long var968 /* : Int */; -val* var969 /* : FlatString */; -static val* varonce970; -val* var971 /* : String */; -char* var972 /* : NativeString */; -long var973 /* : Int */; -val* var974 /* : FlatString */; -val* var975 /* : Array[Object] */; -long var976 /* : Int */; -val* var977 /* : NativeArray[Object] */; +val* var968 /* : FlatString */; +val* var969 /* : String */; +val* var970 /* : String */; +val* var972 /* : NativeArray[String] */; +static val* varonce971; +static val* varonce973; +val* var974 /* : String */; +char* var975 /* : NativeString */; +val* var976 /* : FlatString */; +val* var977 /* : String */; val* var978 /* : String */; -val* var979 /* : String */; -static val* varonce980; -val* var981 /* : String */; -char* var982 /* : NativeString */; -long var983 /* : Int */; -val* var984 /* : FlatString */; -static val* varonce985; -val* var986 /* : String */; -char* var987 /* : NativeString */; -long var988 /* : Int */; -val* var989 /* : FlatString */; -val* var990 /* : Array[Object] */; -long var991 /* : Int */; -val* var992 /* : NativeArray[Object] */; -val* var993 /* : String */; +static val* varonce979; +val* var980 /* : String */; +char* var981 /* : NativeString */; +val* var982 /* : FlatString */; +val* var983 /* : RuntimeVariable */; +val* var_res984 /* var res: RuntimeVariable */; +val* var986 /* : Map[MClass, Array[nullable MProperty]] */; +val* var988 /* : Map[MClass, Array[nullable MProperty]] */; +val* var989 /* : nullable Object */; +val* var_attrs /* var attrs: nullable Array[nullable MProperty] */; +short int var990 /* : Bool */; +short int var991 /* : Bool */; +val* var993 /* : NativeArray[String] */; +static val* varonce992; static val* varonce994; val* var995 /* : String */; char* var996 /* : NativeString */; -long var997 /* : Int */; -val* var998 /* : FlatString */; -val* var999 /* : Array[Object] */; -long var1000 /* : Int */; -val* var1001 /* : NativeArray[Object] */; -val* var1002 /* : String */; -static val* varonce1003; -val* var1004 /* : String */; -char* var1005 /* : NativeString */; -long var1006 /* : Int */; -val* var1007 /* : FlatString */; -val* var1008 /* : RuntimeVariable */; -val* var_res1009 /* var res: RuntimeVariable */; -short int var1010 /* : Bool */; -static val* varonce1012; -val* var1013 /* : String */; -char* var1014 /* : NativeString */; -long var1015 /* : Int */; -val* var1016 /* : FlatString */; -val* var1017 /* : String */; +val* var997 /* : FlatString */; +val* var998 /* : String */; +val* var999 /* : String */; +val* var1001 /* : NativeArray[String] */; +static val* varonce1000; +static val* varonce1002; +val* var1003 /* : String */; +char* var1004 /* : NativeString */; +val* var1005 /* : FlatString */; +static val* varonce1006; +val* var1007 /* : String */; +char* var1008 /* : NativeString */; +val* var1009 /* : FlatString */; +val* var1010 /* : String */; +long var1011 /* : Int */; +long var1013 /* : Int */; +val* var1014 /* : String */; +val* var1015 /* : String */; +val* var1017 /* : NativeArray[String] */; +static val* varonce1016; static val* varonce1018; val* var1019 /* : String */; char* var1020 /* : NativeString */; -long var1021 /* : Int */; -val* var1022 /* : FlatString */; -val* var1023 /* : Array[Object] */; -long var1024 /* : Int */; -val* var1025 /* : NativeArray[Object] */; -val* var1026 /* : String */; -static val* varonce1027; -val* var1028 /* : String */; -char* var1029 /* : NativeString */; -long var1030 /* : Int */; -val* var1031 /* : FlatString */; -val* var1032 /* : Array[Object] */; -long var1033 /* : Int */; -val* var1034 /* : NativeArray[Object] */; -val* var1035 /* : String */; -static val* varonce1036; -val* var1037 /* : String */; -char* var1038 /* : NativeString */; -long var1039 /* : Int */; +val* var1021 /* : FlatString */; +val* var1022 /* : String */; +val* var1023 /* : String */; +static val* varonce1024; +val* var1025 /* : String */; +char* var1026 /* : NativeString */; +val* var1027 /* : FlatString */; +val* var1029 /* : NativeArray[String] */; +static val* varonce1028; +static val* varonce1030; +val* var1031 /* : String */; +char* var1032 /* : NativeString */; +val* var1033 /* : FlatString */; +val* var1034 /* : String */; +val* var1036 /* : NativeArray[String] */; +static val* varonce1035; +static val* varonce1037; +val* var1038 /* : String */; +char* var1039 /* : NativeString */; val* var1040 /* : FlatString */; static val* varonce1041; val* var1042 /* : String */; char* var1043 /* : NativeString */; -long var1044 /* : Int */; -val* var1045 /* : FlatString */; -val* var1046 /* : Array[Object] */; -long var1047 /* : Int */; -val* var1048 /* : NativeArray[Object] */; -val* var1049 /* : String */; -static val* varonce1050; -val* var1051 /* : String */; -char* var1052 /* : NativeString */; -long var1053 /* : Int */; -val* var1054 /* : FlatString */; -static val* varonce1055; -val* var1056 /* : String */; -char* var1057 /* : NativeString */; -long var1058 /* : Int */; -val* var1059 /* : FlatString */; -val* var1060 /* : Array[Object] */; -long var1061 /* : Int */; -val* var1062 /* : NativeArray[Object] */; +val* var1044 /* : FlatString */; +val* var1045 /* : String */; +val* var1046 /* : String */; +short int var1047 /* : Bool */; +short int var1048 /* : Bool */; +short int var1050 /* : Bool */; +short int var1051 /* : Bool */; +val* var1053 /* : NativeArray[String] */; +static val* varonce1052; +static val* varonce1054; +val* var1055 /* : String */; +char* var1056 /* : NativeString */; +val* var1057 /* : FlatString */; +static val* varonce1058; +val* var1059 /* : String */; +char* var1060 /* : NativeString */; +val* var1061 /* : FlatString */; +val* var1062 /* : String */; val* var1063 /* : String */; static val* varonce1064; val* var1065 /* : String */; char* var1066 /* : NativeString */; -long var1067 /* : Int */; -val* var1068 /* : FlatString */; -val* var1069 /* : String */; -static val* varonce1070; -val* var1071 /* : String */; -char* var1072 /* : NativeString */; -long var1073 /* : Int */; -val* var1074 /* : FlatString */; -static val* varonce1075; -val* var1076 /* : String */; -char* var1077 /* : NativeString */; -long var1078 /* : Int */; -val* var1079 /* : FlatString */; -val* var1080 /* : Array[Object] */; -long var1081 /* : Int */; -val* var1082 /* : NativeArray[Object] */; -val* var1083 /* : String */; -static val* varonce1084; -val* var1085 /* : String */; -char* var1086 /* : NativeString */; -long var1087 /* : Int */; -val* var1088 /* : FlatString */; -static val* varonce1089; -val* var1090 /* : String */; -char* var1091 /* : NativeString */; -long var1092 /* : Int */; -val* var1093 /* : FlatString */; -val* var1094 /* : Array[Object] */; -long var1095 /* : Int */; -val* var1096 /* : NativeArray[Object] */; -val* var1097 /* : String */; -static val* varonce1098; -val* var1099 /* : String */; -char* var1100 /* : NativeString */; -long var1101 /* : Int */; -val* var1102 /* : FlatString */; -static val* varonce1103; -val* var1104 /* : String */; -char* var1105 /* : NativeString */; -long var1106 /* : Int */; -val* var1107 /* : FlatString */; -val* var1108 /* : Array[Object] */; -long var1109 /* : Int */; -val* var1110 /* : NativeArray[Object] */; -val* var1111 /* : String */; -val* var1112 /* : String */; -static val* varonce1113; -val* var1114 /* : String */; -char* var1115 /* : NativeString */; -long var1116 /* : Int */; -val* var1117 /* : FlatString */; -static val* varonce1118; -val* var1119 /* : String */; -char* var1120 /* : NativeString */; -long var1121 /* : Int */; -val* var1122 /* : FlatString */; -val* var1123 /* : Array[Object] */; -long var1124 /* : Int */; -val* var1125 /* : NativeArray[Object] */; -val* var1126 /* : String */; -static val* varonce1127; -val* var1128 /* : String */; -char* var1129 /* : NativeString */; -long var1130 /* : Int */; -val* var1131 /* : FlatString */; -static val* varonce1132; -val* var1133 /* : String */; -char* var1134 /* : NativeString */; -long var1135 /* : Int */; -val* var1136 /* : FlatString */; -val* var1137 /* : Array[Object] */; -long var1138 /* : Int */; -val* var1139 /* : NativeArray[Object] */; -val* var1140 /* : String */; -val* var1141 /* : String */; -static val* varonce1142; -val* var1143 /* : String */; -char* var1144 /* : NativeString */; -long var1145 /* : Int */; -val* var1146 /* : FlatString */; -static val* varonce1147; -val* var1148 /* : String */; -char* var1149 /* : NativeString */; -long var1150 /* : Int */; -val* var1151 /* : FlatString */; -val* var1152 /* : Array[Object] */; -long var1153 /* : Int */; -val* var1154 /* : NativeArray[Object] */; -val* var1155 /* : String */; -static val* varonce1156; -val* var1157 /* : String */; -char* var1158 /* : NativeString */; -long var1159 /* : Int */; -val* var1160 /* : FlatString */; -val* var1161 /* : Array[Object] */; -long var1162 /* : Int */; -val* var1163 /* : NativeArray[Object] */; -val* var1164 /* : String */; -static val* varonce1165; -val* var1166 /* : String */; -char* var1167 /* : NativeString */; -long var1168 /* : Int */; -val* var1169 /* : FlatString */; -val* var1170 /* : RuntimeVariable */; -val* var_res1171 /* var res: RuntimeVariable */; -short int var1172 /* : Bool */; -static val* varonce1174; -val* var1175 /* : String */; -char* var1176 /* : NativeString */; -long var1177 /* : Int */; -val* var1178 /* : FlatString */; -long var1179 /* : Int */; -long var1181 /* : Int */; -static val* varonce1182; -val* var1183 /* : String */; -char* var1184 /* : NativeString */; -long var1185 /* : Int */; -val* var1186 /* : FlatString */; -val* var1187 /* : Array[Object] */; -long var1188 /* : Int */; -val* var1189 /* : NativeArray[Object] */; -val* var1190 /* : Object */; -val* var1191 /* : String */; -static val* varonce1192; -val* var1193 /* : String */; -char* var1194 /* : NativeString */; -long var1195 /* : Int */; -val* var1196 /* : FlatString */; -val* var1197 /* : Array[Object] */; -long var1198 /* : Int */; -val* var1199 /* : NativeArray[Object] */; -val* var1200 /* : String */; -static val* varonce1201; -val* var1202 /* : String */; -char* var1203 /* : NativeString */; -long var1204 /* : Int */; -val* var1205 /* : FlatString */; -static val* varonce1206; -val* var1207 /* : String */; -char* var1208 /* : NativeString */; -long var1209 /* : Int */; -val* var1210 /* : FlatString */; -val* var1211 /* : Array[Object] */; -long var1212 /* : Int */; -val* var1213 /* : NativeArray[Object] */; -val* var1214 /* : String */; -static val* varonce1215; -val* var1216 /* : String */; -char* var1217 /* : NativeString */; -long var1218 /* : Int */; -val* var1219 /* : FlatString */; -static val* varonce1220; -val* var1221 /* : String */; -char* var1222 /* : NativeString */; -long var1223 /* : Int */; -val* var1224 /* : FlatString */; -val* var1225 /* : Array[Object] */; -long var1226 /* : Int */; -val* var1227 /* : NativeArray[Object] */; -val* var1228 /* : String */; -static val* varonce1229; -val* var1230 /* : String */; -char* var1231 /* : NativeString */; -long var1232 /* : Int */; -val* var1233 /* : FlatString */; -static val* varonce1234; -val* var1235 /* : String */; -char* var1236 /* : NativeString */; -long var1237 /* : Int */; -val* var1238 /* : FlatString */; -val* var1239 /* : Array[Object] */; -long var1240 /* : Int */; -val* var1241 /* : NativeArray[Object] */; -val* var1242 /* : String */; -static val* varonce1243; -val* var1244 /* : String */; -char* var1245 /* : NativeString */; -long var1246 /* : Int */; -val* var1247 /* : FlatString */; +val* var1067 /* : FlatString */; var_mclass = p0; { { /* Inline model#MClass#intro (var_mclass) on */ var2 = var_mclass->attrs[COLOR_nit__model__MClass___intro].val; /* _intro on */ if (unlikely(var2 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 423); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 460); +fatal_exit(1); } var = var2; RET_LABEL1:(void)0; @@ -1231,8 +1587,8 @@ RET_LABEL1:(void)0; var5 = var->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ if (unlikely(var5 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 495); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 556); +fatal_exit(1); } var3 = var5; RET_LABEL4:(void)0; @@ -1244,3810 +1600,3307 @@ var6 = nit___nit__MClass___nit__model_base__MEntity__c_name(var_mclass); } var_c_name = var6; { -{ /* Inline separate_compiler#SeparateCompiler#method_tables (self) on */ -var9 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___method_tables].val; /* _method_tables on */ -if (unlikely(var9 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _method_tables"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 856); -show_backtrace(1); -} -var7 = var9; -RET_LABEL8:(void)0; -} -} -{ -var10 = ((val* (*)(val* self, val* p0))(var7->class->vft[COLOR_standard__abstract_collection__MapRead___91d_93d]))(var7, var_mclass) /* [] on */; -} -var_vft = var10; -{ -{ /* Inline separate_compiler#SeparateCompiler#attr_tables (self) on */ -var13 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___attr_tables].val; /* _attr_tables on */ -if (unlikely(var13 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _attr_tables"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 857); -show_backtrace(1); -} -var11 = var13; -RET_LABEL12:(void)0; -} -} -{ -var14 = ((val* (*)(val* self, val* p0))(var11->class->vft[COLOR_standard__abstract_collection__MapRead___91d_93d]))(var11, var_mclass) /* [] on */; -} -var_attrs = var14; -{ -var15 = ((val* (*)(val* self))(self->class->vft[COLOR_nit__abstract_compiler__AbstractCompiler__new_visitor]))(self) /* new_visitor on */; +var7 = ((val*(*)(val* self))(self->class->vft[COLOR_nit__abstract_compiler__AbstractCompiler__new_visitor]))(self); /* new_visitor on */ } -var_v = var15; +var_v = var7; { { /* Inline separate_compiler#SeparateCompiler#runtime_type_analysis (self) on */ -var18 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___runtime_type_analysis].val; /* _runtime_type_analysis on */ -var16 = var18; -RET_LABEL17:(void)0; +var10 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___runtime_type_analysis].val; /* _runtime_type_analysis on */ +var8 = var10; +RET_LABEL9:(void)0; } } -var_rta = var16; -var23 = NULL; +var_rta = var8; if (var_rta == NULL) { -var24 = 0; /* is null */ +var15 = 0; /* is null */ } else { -var24 = 1; /* arg is null and recv is not */ +var15 = 1; /* arg is null and recv is not */ } if (0) { -{ /* Inline kernel#Object#!= (var_rta,var23) on */ -var_other = var23; +{ /* Inline kernel#Object#!= (var_rta,((val*)NULL)) on */ +var_other = ((val*)NULL); { -var27 = ((short int (*)(val* self, val* p0))(var_rta->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_rta, var_other) /* == on */; +var18 = ((short int(*)(val* self, val* p0))(var_rta->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_rta, var_other); /* == on */ } -var28 = !var27; -var25 = var28; -goto RET_LABEL26; -RET_LABEL26:(void)0; +var19 = !var18; +var16 = var19; +goto RET_LABEL17; +RET_LABEL17:(void)0; } -var24 = var25; +var15 = var16; } -var_ = var24; -if (var24){ +var_ = var15; +if (var15){ { { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_classes (var_rta) on */ -var31 = var_rta->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_classes].val; /* _live_classes on */ -if (unlikely(var31 == NULL)) { +var22 = var_rta->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_classes].val; /* _live_classes on */ +if (unlikely(var22 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_classes"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 62); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 69); +fatal_exit(1); } -var29 = var31; -RET_LABEL30:(void)0; -} -} -{ -var32 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var29, var_mclass); +var20 = var22; +RET_LABEL21:(void)0; } -var33 = !var32; -var22 = var33; -} else { -var22 = var_; } -var_34 = var22; -if (var22){ { -var35 = nit__abstract_compiler___MClassType___MType__ctype(var_mtype); +var23 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var20, var_mclass); } -if (varonce) { -var36 = varonce; +var24 = !var23; +var14 = var24; } else { -var37 = "val*"; -var38 = 4; -var39 = standard___standard__NativeString___to_s_with_length(var37, var38); -var36 = var39; -varonce = var36; +var14 = var_; } +var_25 = var14; +if (var14){ { -var40 = ((short int (*)(val* self, val* p0))(var35->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var35, var36) /* == on */; +var26 = nit__abstract_compiler___MClassType___MType__is_c_primitive(var_mtype); } -var21 = var40; +var27 = !var26; +var13 = var27; } else { -var21 = var_34; +var13 = var_25; } -var_41 = var21; -if (var21){ +var_28 = var13; +if (var13){ { { /* Inline model#MClass#name (var_mclass) on */ -var44 = var_mclass->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ -if (unlikely(var44 == NULL)) { +var31 = var_mclass->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ +if (unlikely(var31 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 348); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 362); +fatal_exit(1); } -var42 = var44; -RET_LABEL43:(void)0; +var29 = var31; +RET_LABEL30:(void)0; } } -if (varonce45) { -var46 = varonce45; +if (likely(varonce!=NULL)) { +var32 = varonce; } else { -var47 = "NativeArray"; -var48 = 11; -var49 = standard___standard__NativeString___to_s_with_length(var47, var48); -var46 = var49; -varonce45 = var46; +var33 = "NativeArray"; +var34 = standard___standard__NativeString___to_s_with_length(var33, 11l); +var32 = var34; +varonce = var32; } { -{ /* Inline kernel#Object#!= (var42,var46) on */ -var_other = var46; +{ /* Inline kernel#Object#!= (var29,var32) on */ +var_other = var32; { -var52 = ((short int (*)(val* self, val* p0))(var42->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var42, var_other) /* == on */; +var37 = ((short int(*)(val* self, val* p0))(var29->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var29, var_other); /* == on */ } -var53 = !var52; -var50 = var53; -goto RET_LABEL51; -RET_LABEL51:(void)0; +var38 = !var37; +var35 = var38; +goto RET_LABEL36; +RET_LABEL36:(void)0; } } -var20 = var50; +var12 = var35; } else { -var20 = var_41; +var12 = var_28; } -var_54 = var20; -if (var20){ +var_39 = var12; +if (var12){ { { /* Inline model#MClass#name (var_mclass) on */ -var57 = var_mclass->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ -if (unlikely(var57 == NULL)) { +var42 = var_mclass->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ +if (unlikely(var42 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 348); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 362); +fatal_exit(1); } -var55 = var57; -RET_LABEL56:(void)0; +var40 = var42; +RET_LABEL41:(void)0; } } -if (varonce58) { -var59 = varonce58; +if (likely(varonce43!=NULL)) { +var44 = varonce43; } else { -var60 = "Pointer"; -var61 = 7; -var62 = standard___standard__NativeString___to_s_with_length(var60, var61); -var59 = var62; -varonce58 = var59; +var45 = "Pointer"; +var46 = standard___standard__NativeString___to_s_with_length(var45, 7l); +var44 = var46; +varonce43 = var44; } { -{ /* Inline kernel#Object#!= (var55,var59) on */ -var_other = var59; +{ /* Inline kernel#Object#!= (var40,var44) on */ +var_other = var44; { -var65 = ((short int (*)(val* self, val* p0))(var55->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var55, var_other) /* == on */; +var49 = ((short int(*)(val* self, val* p0))(var40->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var40, var_other); /* == on */ } -var66 = !var65; -var63 = var66; -goto RET_LABEL64; -RET_LABEL64:(void)0; +var50 = !var49; +var47 = var50; +goto RET_LABEL48; +RET_LABEL48:(void)0; } } -var19 = var63; +var11 = var47; } else { -var19 = var_54; +var11 = var_39; } -var_is_dead = var19; -if (varonce67) { -var68 = varonce67; +var_is_dead = var11; +if (unlikely(varonce51==NULL)) { +var52 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce53!=NULL)) { +var54 = varonce53; } else { -var69 = "/* runtime class "; -var70 = 17; -var71 = standard___standard__NativeString___to_s_with_length(var69, var70); -var68 = var71; -varonce67 = var68; +var55 = "/* runtime class "; +var56 = standard___standard__NativeString___to_s_with_length(var55, 17l); +var54 = var56; +varonce53 = var54; } -if (varonce72) { -var73 = varonce72; +((struct instance_standard__NativeArray*)var52)->values[0]=var54; +if (likely(varonce57!=NULL)) { +var58 = varonce57; } else { -var74 = " */"; -var75 = 3; -var76 = standard___standard__NativeString___to_s_with_length(var74, var75); -var73 = var76; -varonce72 = var73; -} -var77 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var77 = array_instance Array[Object] */ -var78 = 3; -var79 = NEW_standard__NativeArray(var78, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var79)->values[0] = (val*) var68; -((struct instance_standard__NativeArray*)var79)->values[1] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var79)->values[2] = (val*) var73; -{ -((void (*)(val* self, val* p0, long p1))(var77->class->vft[COLOR_standard__array__Array__with_native]))(var77, var79, var78) /* with_native on */; +var59 = " */"; +var60 = standard___standard__NativeString___to_s_with_length(var59, 3l); +var58 = var60; +varonce57 = var58; } +((struct instance_standard__NativeArray*)var52)->values[2]=var58; +} else { +var52 = varonce51; +varonce51 = NULL; } +((struct instance_standard__NativeArray*)var52)->values[1]=var_c_name; { -var80 = ((val* (*)(val* self))(var77->class->vft[COLOR_standard__string__Object__to_s]))(var77) /* to_s on */; +var61 = ((val*(*)(val* self))(var52->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var52); /* native_to_s on */ } +varonce51 = var52; { -nit___nit__AbstractCompilerVisitor___add_decl(var_v, var80); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var61); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } -var81 = !var_is_dead; -if (var81){ -if (varonce82) { -var83 = varonce82; +var62 = !var_is_dead; +if (var62){ +if (unlikely(varonce63==NULL)) { +var64 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce65!=NULL)) { +var66 = varonce65; } else { -var84 = "class_"; -var85 = 6; -var86 = standard___standard__NativeString___to_s_with_length(var84, var85); -var83 = var86; -varonce82 = var83; -} -var87 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var87 = array_instance Array[Object] */ -var88 = 2; -var89 = NEW_standard__NativeArray(var88, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var89)->values[0] = (val*) var83; -((struct instance_standard__NativeArray*)var89)->values[1] = (val*) var_c_name; -{ -((void (*)(val* self, val* p0, long p1))(var87->class->vft[COLOR_standard__array__Array__with_native]))(var87, var89, var88) /* with_native on */; +var67 = "class_"; +var68 = standard___standard__NativeString___to_s_with_length(var67, 6l); +var66 = var68; +varonce65 = var66; } +((struct instance_standard__NativeArray*)var64)->values[0]=var66; +} else { +var64 = varonce63; +varonce63 = NULL; } +((struct instance_standard__NativeArray*)var64)->values[1]=var_c_name; { -var90 = ((val* (*)(val* self))(var87->class->vft[COLOR_standard__string__Object__to_s]))(var87) /* to_s on */; +var69 = ((val*(*)(val* self))(var64->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var64); /* native_to_s on */ } -if (varonce91) { -var92 = varonce91; +varonce63 = var64; +if (unlikely(varonce70==NULL)) { +var71 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce72!=NULL)) { +var73 = varonce72; } else { -var93 = "extern const struct class class_"; -var94 = 32; -var95 = standard___standard__NativeString___to_s_with_length(var93, var94); -var92 = var95; -varonce91 = var92; +var74 = "extern const struct class class_"; +var75 = standard___standard__NativeString___to_s_with_length(var74, 32l); +var73 = var75; +varonce72 = var73; } -if (varonce96) { -var97 = varonce96; +((struct instance_standard__NativeArray*)var71)->values[0]=var73; +if (likely(varonce76!=NULL)) { +var77 = varonce76; } else { -var98 = ";"; -var99 = 1; -var100 = standard___standard__NativeString___to_s_with_length(var98, var99); -var97 = var100; -varonce96 = var97; -} -var101 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var101 = array_instance Array[Object] */ -var102 = 3; -var103 = NEW_standard__NativeArray(var102, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var103)->values[0] = (val*) var92; -((struct instance_standard__NativeArray*)var103)->values[1] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var103)->values[2] = (val*) var97; -{ -((void (*)(val* self, val* p0, long p1))(var101->class->vft[COLOR_standard__array__Array__with_native]))(var101, var103, var102) /* with_native on */; +var78 = ";"; +var79 = standard___standard__NativeString___to_s_with_length(var78, 1l); +var77 = var79; +varonce76 = var77; } +((struct instance_standard__NativeArray*)var71)->values[2]=var77; +} else { +var71 = varonce70; +varonce70 = NULL; } +((struct instance_standard__NativeArray*)var71)->values[1]=var_c_name; { -var104 = ((val* (*)(val* self))(var101->class->vft[COLOR_standard__string__Object__to_s]))(var101) /* to_s on */; +var80 = ((val*(*)(val* self))(var71->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var71); /* native_to_s on */ } +varonce70 = var71; { -nit___nit__AbstractCompiler___provide_declaration(self, var90, var104); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ +nit___nit__AbstractCompiler___provide_declaration(self, var69, var80); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ +} +if (unlikely(varonce81==NULL)) { +var82 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce83!=NULL)) { +var84 = varonce83; +} else { +var85 = "const struct class class_"; +var86 = standard___standard__NativeString___to_s_with_length(var85, 25l); +var84 = var86; +varonce83 = var84; } -if (varonce105) { -var106 = varonce105; +((struct instance_standard__NativeArray*)var82)->values[0]=var84; +if (likely(varonce87!=NULL)) { +var88 = varonce87; } else { -var107 = "const struct class class_"; -var108 = 25; -var109 = standard___standard__NativeString___to_s_with_length(var107, var108); -var106 = var109; -varonce105 = var106; +var89 = " = {"; +var90 = standard___standard__NativeString___to_s_with_length(var89, 4l); +var88 = var90; +varonce87 = var88; } -if (varonce110) { -var111 = varonce110; +((struct instance_standard__NativeArray*)var82)->values[2]=var88; } else { -var112 = " = {"; -var113 = 4; -var114 = standard___standard__NativeString___to_s_with_length(var112, var113); -var111 = var114; -varonce110 = var111; +var82 = varonce81; +varonce81 = NULL; +} +((struct instance_standard__NativeArray*)var82)->values[1]=var_c_name; +{ +var91 = ((val*(*)(val* self))(var82->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var82); /* native_to_s on */ } -var115 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var115 = array_instance Array[Object] */ -var116 = 3; -var117 = NEW_standard__NativeArray(var116, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var117)->values[0] = (val*) var106; -((struct instance_standard__NativeArray*)var117)->values[1] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var117)->values[2] = (val*) var111; +varonce81 = var82; { -((void (*)(val* self, val* p0, long p1))(var115->class->vft[COLOR_standard__array__Array__with_native]))(var115, var117, var116) /* with_native on */; +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var91); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } +if (unlikely(varonce92==NULL)) { +var93 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce94!=NULL)) { +var95 = varonce94; +} else { +var96 = ", /* box_kind */"; +var97 = standard___standard__NativeString___to_s_with_length(var96, 16l); +var95 = var97; +varonce94 = var95; +} +((struct instance_standard__NativeArray*)var93)->values[1]=var95; +} else { +var93 = varonce92; +varonce92 = NULL; } { -var118 = ((val* (*)(val* self))(var115->class->vft[COLOR_standard__string__Object__to_s]))(var115) /* to_s on */; +var98 = nit___nit__SeparateCompiler___box_kind_of(self, var_mclass); } +var99 = standard__string___Int___Object__to_s(var98); +((struct instance_standard__NativeArray*)var93)->values[0]=var99; { -nit___nit__AbstractCompilerVisitor___add_decl(var_v, var118); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +var100 = ((val*(*)(val* self))(var93->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var93); /* native_to_s on */ } +varonce92 = var93; { -var119 = nit___nit__SeparateCompiler___box_kind_of(self, var_mclass); +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var100); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } -if (varonce120) { -var121 = varonce120; +if (likely(varonce101!=NULL)) { +var102 = varonce101; } else { -var122 = ", /* box_kind */"; -var123 = 16; -var124 = standard___standard__NativeString___to_s_with_length(var122, var123); -var121 = var124; -varonce120 = var121; +var103 = "{"; +var104 = standard___standard__NativeString___to_s_with_length(var103, 1l); +var102 = var104; +varonce101 = var102; } -var125 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var125 = array_instance Array[Object] */ -var126 = 2; -var127 = NEW_standard__NativeArray(var126, &type_standard__NativeArray__standard__Object); -var128 = BOX_standard__Int(var119); /* autobox from Int to Object */ -((struct instance_standard__NativeArray*)var127)->values[0] = (val*) var128; -((struct instance_standard__NativeArray*)var127)->values[1] = (val*) var121; { -((void (*)(val* self, val* p0, long p1))(var125->class->vft[COLOR_standard__array__Array__with_native]))(var125, var127, var126) /* with_native on */; -} +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var102); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } { -var129 = ((val* (*)(val* self))(var125->class->vft[COLOR_standard__string__Object__to_s]))(var125) /* to_s on */; +{ /* Inline separate_compiler#SeparateCompiler#method_tables (self) on */ +var107 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___method_tables].val; /* _method_tables on */ +if (unlikely(var107 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _method_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 1053); +fatal_exit(1); +} +var105 = var107; +RET_LABEL106:(void)0; +} } { -nit___nit__AbstractCompilerVisitor___add_decl(var_v, var129); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +var108 = ((val*(*)(val* self, val* p0))((((long)var105&3)?class_info[((long)var105&3)]:var105->class)->vft[COLOR_standard__abstract_collection__MapRead__get_or_null]))(var105, var_mclass); /* get_or_null on */ } -if (varonce130) { -var131 = varonce130; +var_vft = var108; +if (var_vft == NULL) { +var109 = 0; /* is null */ } else { -var132 = "{"; -var133 = 1; -var134 = standard___standard__NativeString___to_s_with_length(var132, var133); -var131 = var134; -varonce130 = var131; +var109 = 1; /* arg is null and recv is not */ } +if (0) { +{ /* Inline kernel#Object#!= (var_vft,((val*)NULL)) on */ +var_other = ((val*)NULL); { -nit___nit__AbstractCompilerVisitor___add_decl(var_v, var131); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +var112 = ((short int(*)(val* self, val* p0))(var_vft->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_vft, var_other); /* == on */ } -var135 = 0; -var_i = var135; +var113 = !var112; +var110 = var113; +goto RET_LABEL111; +RET_LABEL111:(void)0; +} +var109 = var110; +} +if (var109){ +var_i = 0l; { -{ /* Inline array#AbstractArrayRead#length (var_vft) on */ -var138 = var_vft->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ -var136 = var138; -RET_LABEL137:(void)0; +{ /* Inline array#AbstractArrayRead#length (var_vft) on */ +var116 = var_vft->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ +var114 = var116; +RET_LABEL115:(void)0; } } -var_139 = var136; +var_117 = var114; for(;;) { { -{ /* Inline kernel#Int#< (var_i,var_139) on */ -/* Covariant cast for argument 0 (i) isa OTHER */ -/* isa OTHER */ -var142 = 1; /* easy isa OTHER*/ -if (unlikely(!var142)) { +{ /* Inline kernel#Int#< (var_i,var_117) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var120 = 1; /* easy isa OTHER*/ +if (unlikely(!var120)) { var_class_name = type_standard__Int.name; PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); -PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 410); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 534); +fatal_exit(1); } -var143 = var_i < var_139; -var140 = var143; -goto RET_LABEL141; -RET_LABEL141:(void)0; +var121 = var_i < var_117; +var118 = var121; +goto RET_LABEL119; +RET_LABEL119:(void)0; } } -if (var140){ +if (var118){ { -var144 = standard___standard__Array___standard__abstract_collection__SequenceRead___91d_93d(var_vft, var_i); +var122 = standard___standard__Array___standard__abstract_collection__SequenceRead___91d_93d(var_vft, var_i); } -var_mpropdef = var144; -var145 = NULL; +var_mpropdef = var122; if (var_mpropdef == NULL) { -var146 = 1; /* is null */ +var123 = 1; /* is null */ } else { -var146 = 0; /* arg is null but recv is not */ +var123 = 0; /* arg is null but recv is not */ } if (0) { -{ /* Inline kernel#Object#== (var_mpropdef,var145) on */ -var_other149 = var145; +{ /* Inline kernel#Object#== (var_mpropdef,((val*)NULL)) on */ +var_other126 = ((val*)NULL); { -{ /* Inline kernel#Object#is_same_instance (var_mpropdef,var_other149) on */ -var152 = var_mpropdef == var_other149; -var150 = var152; -goto RET_LABEL151; -RET_LABEL151:(void)0; +{ /* Inline kernel#Object#is_same_instance (var_mpropdef,var_other126) on */ +var129 = var_mpropdef == var_other126; +var127 = var129; +goto RET_LABEL128; +RET_LABEL128:(void)0; } } -var147 = var150; -goto RET_LABEL148; -RET_LABEL148:(void)0; +var124 = var127; +goto RET_LABEL125; +RET_LABEL125:(void)0; } -var146 = var147; +var123 = var124; } -if (var146){ -if (varonce153) { -var154 = varonce153; +if (var123){ +if (likely(varonce130!=NULL)) { +var131 = varonce130; } else { -var155 = "NULL, /* empty */"; -var156 = 17; -var157 = standard___standard__NativeString___to_s_with_length(var155, var156); -var154 = var157; -varonce153 = var154; +var132 = "NULL, /* empty */"; +var133 = standard___standard__NativeString___to_s_with_length(var132, 17l); +var131 = var133; +varonce130 = var131; } { -nit___nit__AbstractCompilerVisitor___add_decl(var_v, var154); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var131); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } } else { /* isa MMethodDef */ -cltype159 = type_nit__MMethodDef.color; -idtype160 = type_nit__MMethodDef.id; -if(cltype159 >= var_mpropdef->type->table_size) { -var158 = 0; +cltype135 = type_nit__MMethodDef.color; +idtype136 = type_nit__MMethodDef.id; +if(cltype135 >= var_mpropdef->type->table_size) { +var134 = 0; } else { -var158 = var_mpropdef->type->type_table[cltype159] == idtype160; +var134 = var_mpropdef->type->type_table[cltype135] == idtype136; } -if (unlikely(!var158)) { +if (unlikely(!var134)) { PRINT_ERROR("Runtime error: %s", "Assert failed"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 703); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 838); +fatal_exit(1); } -var162 = NULL; if (var_rta == NULL) { -var163 = 0; /* is null */ +var138 = 0; /* is null */ } else { -var163 = 1; /* arg is null and recv is not */ +var138 = 1; /* arg is null and recv is not */ } if (0) { -{ /* Inline kernel#Object#!= (var_rta,var162) on */ -var_other = var162; +{ /* Inline kernel#Object#!= (var_rta,((val*)NULL)) on */ +var_other = ((val*)NULL); { -var166 = ((short int (*)(val* self, val* p0))(var_rta->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_rta, var_other) /* == on */; +var141 = ((short int(*)(val* self, val* p0))(var_rta->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_rta, var_other); /* == on */ } -var167 = !var166; -var164 = var167; -goto RET_LABEL165; -RET_LABEL165:(void)0; +var142 = !var141; +var139 = var142; +goto RET_LABEL140; +RET_LABEL140:(void)0; } -var163 = var164; +var138 = var139; } -var_168 = var163; -if (var163){ +var_143 = var138; +if (var138){ { { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_methoddefs (var_rta) on */ -var171 = var_rta->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_methoddefs].val; /* _live_methoddefs on */ -if (unlikely(var171 == NULL)) { +var146 = var_rta->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_methoddefs].val; /* _live_methoddefs on */ +if (unlikely(var146 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_methoddefs"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 72); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 79); +fatal_exit(1); } -var169 = var171; -RET_LABEL170:(void)0; +var144 = var146; +RET_LABEL145:(void)0; } } { -var172 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var169, var_mpropdef); +var147 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var144, var_mpropdef); } -var173 = !var172; -var161 = var173; +var148 = !var147; +var137 = var148; } else { -var161 = var_168; +var137 = var_143; } -if (var161){ -if (varonce174) { -var175 = varonce174; +if (var137){ +if (unlikely(varonce149==NULL)) { +var150 = NEW_standard__NativeArray(7l, &type_standard__NativeArray__standard__String); +if (likely(varonce151!=NULL)) { +var152 = varonce151; } else { -var176 = "NULL, /* DEAD "; -var177 = 14; -var178 = standard___standard__NativeString___to_s_with_length(var176, var177); -var175 = var178; -varonce174 = var175; -} -{ -{ /* Inline model#MClass#intro_mmodule (var_mclass) on */ -var181 = var_mclass->attrs[COLOR_nit__model__MClass___intro_mmodule].val; /* _intro_mmodule on */ -if (unlikely(var181 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro_mmodule"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 343); -show_backtrace(1); -} -var179 = var181; -RET_LABEL180:(void)0; +var153 = "NULL, /* DEAD "; +var154 = standard___standard__NativeString___to_s_with_length(var153, 14l); +var152 = var154; +varonce151 = var152; } +((struct instance_standard__NativeArray*)var150)->values[0]=var152; +if (likely(varonce155!=NULL)) { +var156 = varonce155; +} else { +var157 = ":"; +var158 = standard___standard__NativeString___to_s_with_length(var157, 1l); +var156 = var158; +varonce155 = var156; } -if (varonce182) { -var183 = varonce182; +((struct instance_standard__NativeArray*)var150)->values[2]=var156; +if (likely(varonce159!=NULL)) { +var160 = varonce159; } else { -var184 = ":"; -var185 = 1; -var186 = standard___standard__NativeString___to_s_with_length(var184, var185); -var183 = var186; -varonce182 = var183; +var161 = ":"; +var162 = standard___standard__NativeString___to_s_with_length(var161, 1l); +var160 = var162; +varonce159 = var160; } -if (varonce187) { -var188 = varonce187; +((struct instance_standard__NativeArray*)var150)->values[4]=var160; +if (likely(varonce163!=NULL)) { +var164 = varonce163; } else { -var189 = ":"; -var190 = 1; -var191 = standard___standard__NativeString___to_s_with_length(var189, var190); -var188 = var191; -varonce187 = var188; +var165 = " */"; +var166 = standard___standard__NativeString___to_s_with_length(var165, 3l); +var164 = var166; +varonce163 = var164; } -if (varonce192) { -var193 = varonce192; +((struct instance_standard__NativeArray*)var150)->values[6]=var164; } else { -var194 = " */"; -var195 = 3; -var196 = standard___standard__NativeString___to_s_with_length(var194, var195); -var193 = var196; -varonce192 = var193; +var150 = varonce149; +varonce149 = NULL; +} +{ +{ /* Inline model#MClass#intro_mmodule (var_mclass) on */ +var169 = var_mclass->attrs[COLOR_nit__model__MClass___intro_mmodule].val; /* _intro_mmodule on */ +if (unlikely(var169 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro_mmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 357); +fatal_exit(1); +} +var167 = var169; +RET_LABEL168:(void)0; +} } -var197 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var197 = array_instance Array[Object] */ -var198 = 7; -var199 = NEW_standard__NativeArray(var198, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var199)->values[0] = (val*) var175; -((struct instance_standard__NativeArray*)var199)->values[1] = (val*) var179; -((struct instance_standard__NativeArray*)var199)->values[2] = (val*) var183; -((struct instance_standard__NativeArray*)var199)->values[3] = (val*) var_mclass; -((struct instance_standard__NativeArray*)var199)->values[4] = (val*) var188; -((struct instance_standard__NativeArray*)var199)->values[5] = (val*) var_mpropdef; -((struct instance_standard__NativeArray*)var199)->values[6] = (val*) var193; { -((void (*)(val* self, val* p0, long p1))(var197->class->vft[COLOR_standard__array__Array__with_native]))(var197, var199, var198) /* with_native on */; +var170 = ((val*(*)(val* self))(var167->class->vft[COLOR_standard__string__Object__to_s]))(var167); /* to_s on */ } +((struct instance_standard__NativeArray*)var150)->values[1]=var170; +{ +var171 = ((val*(*)(val* self))(var_mclass->class->vft[COLOR_standard__string__Object__to_s]))(var_mclass); /* to_s on */ +} +((struct instance_standard__NativeArray*)var150)->values[3]=var171; +{ +var172 = ((val*(*)(val* self))(var_mpropdef->class->vft[COLOR_standard__string__Object__to_s]))(var_mpropdef); /* to_s on */ } +((struct instance_standard__NativeArray*)var150)->values[5]=var172; { -var200 = ((val* (*)(val* self))(var197->class->vft[COLOR_standard__string__Object__to_s]))(var197) /* to_s on */; +var173 = ((val*(*)(val* self))(var150->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var150); /* native_to_s on */ } +varonce149 = var150; { -nit___nit__AbstractCompilerVisitor___add_decl(var_v, var200); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var173); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } goto BREAK_label; } else { } { -var201 = nit__separate_compiler___MMethodDef___virtual_runtime_function(var_mpropdef); +var174 = nit__separate_compiler___MMethodDef___virtual_runtime_function(var_mpropdef); } -var_rf = var201; +var_rf = var174; { -var202 = nit___nit__AbstractRuntimeFunction___c_name(var_rf); +var175 = nit___nit__AbstractRuntimeFunction___c_name(var_rf); } { -nit___nit__AbstractCompilerVisitor___require_declaration(var_v, var202); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +nit___nit__AbstractCompilerVisitor___require_declaration(var_v, var175); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ } -if (varonce203) { -var204 = varonce203; +if (unlikely(varonce176==NULL)) { +var177 = NEW_standard__NativeArray(9l, &type_standard__NativeArray__standard__String); +if (likely(varonce178!=NULL)) { +var179 = varonce178; } else { -var205 = "(nitmethod_t)"; -var206 = 13; -var207 = standard___standard__NativeString___to_s_with_length(var205, var206); -var204 = var207; -varonce203 = var204; +var180 = "(nitmethod_t)"; +var181 = standard___standard__NativeString___to_s_with_length(var180, 13l); +var179 = var181; +varonce178 = var179; } -{ -var208 = nit___nit__AbstractRuntimeFunction___c_name(var_rf); +((struct instance_standard__NativeArray*)var177)->values[0]=var179; +if (likely(varonce182!=NULL)) { +var183 = varonce182; +} else { +var184 = ", /* pointer to "; +var185 = standard___standard__NativeString___to_s_with_length(var184, 16l); +var183 = var185; +varonce182 = var183; +} +((struct instance_standard__NativeArray*)var177)->values[2]=var183; +if (likely(varonce186!=NULL)) { +var187 = varonce186; +} else { +var188 = ":"; +var189 = standard___standard__NativeString___to_s_with_length(var188, 1l); +var187 = var189; +varonce186 = var187; +} +((struct instance_standard__NativeArray*)var177)->values[4]=var187; +if (likely(varonce190!=NULL)) { +var191 = varonce190; +} else { +var192 = ":"; +var193 = standard___standard__NativeString___to_s_with_length(var192, 1l); +var191 = var193; +varonce190 = var191; +} +((struct instance_standard__NativeArray*)var177)->values[6]=var191; +if (likely(varonce194!=NULL)) { +var195 = varonce194; +} else { +var196 = " */"; +var197 = standard___standard__NativeString___to_s_with_length(var196, 3l); +var195 = var197; +varonce194 = var195; } -if (varonce209) { -var210 = varonce209; +((struct instance_standard__NativeArray*)var177)->values[8]=var195; } else { -var211 = ", /* pointer to "; -var212 = 16; -var213 = standard___standard__NativeString___to_s_with_length(var211, var212); -var210 = var213; -varonce209 = var210; +var177 = varonce176; +varonce176 = NULL; +} +{ +var198 = nit___nit__AbstractRuntimeFunction___c_name(var_rf); } +((struct instance_standard__NativeArray*)var177)->values[1]=var198; { { /* Inline model#MClass#intro_mmodule (var_mclass) on */ -var216 = var_mclass->attrs[COLOR_nit__model__MClass___intro_mmodule].val; /* _intro_mmodule on */ -if (unlikely(var216 == NULL)) { +var201 = var_mclass->attrs[COLOR_nit__model__MClass___intro_mmodule].val; /* _intro_mmodule on */ +if (unlikely(var201 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro_mmodule"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 343); -show_backtrace(1); -} -var214 = var216; -RET_LABEL215:(void)0; +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 357); +fatal_exit(1); } +var199 = var201; +RET_LABEL200:(void)0; } -if (varonce217) { -var218 = varonce217; -} else { -var219 = ":"; -var220 = 1; -var221 = standard___standard__NativeString___to_s_with_length(var219, var220); -var218 = var221; -varonce217 = var218; -} -if (varonce222) { -var223 = varonce222; -} else { -var224 = ":"; -var225 = 1; -var226 = standard___standard__NativeString___to_s_with_length(var224, var225); -var223 = var226; -varonce222 = var223; } -if (varonce227) { -var228 = varonce227; -} else { -var229 = " */"; -var230 = 3; -var231 = standard___standard__NativeString___to_s_with_length(var229, var230); -var228 = var231; -varonce227 = var228; +{ +var202 = ((val*(*)(val* self))(var199->class->vft[COLOR_standard__string__Object__to_s]))(var199); /* to_s on */ } -var232 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var232 = array_instance Array[Object] */ -var233 = 9; -var234 = NEW_standard__NativeArray(var233, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var234)->values[0] = (val*) var204; -((struct instance_standard__NativeArray*)var234)->values[1] = (val*) var208; -((struct instance_standard__NativeArray*)var234)->values[2] = (val*) var210; -((struct instance_standard__NativeArray*)var234)->values[3] = (val*) var214; -((struct instance_standard__NativeArray*)var234)->values[4] = (val*) var218; -((struct instance_standard__NativeArray*)var234)->values[5] = (val*) var_mclass; -((struct instance_standard__NativeArray*)var234)->values[6] = (val*) var223; -((struct instance_standard__NativeArray*)var234)->values[7] = (val*) var_mpropdef; -((struct instance_standard__NativeArray*)var234)->values[8] = (val*) var228; +((struct instance_standard__NativeArray*)var177)->values[3]=var202; { -((void (*)(val* self, val* p0, long p1))(var232->class->vft[COLOR_standard__array__Array__with_native]))(var232, var234, var233) /* with_native on */; +var203 = ((val*(*)(val* self))(var_mclass->class->vft[COLOR_standard__string__Object__to_s]))(var_mclass); /* to_s on */ } +((struct instance_standard__NativeArray*)var177)->values[5]=var203; +{ +var204 = ((val*(*)(val* self))(var_mpropdef->class->vft[COLOR_standard__string__Object__to_s]))(var_mpropdef); /* to_s on */ } +((struct instance_standard__NativeArray*)var177)->values[7]=var204; { -var235 = ((val* (*)(val* self))(var232->class->vft[COLOR_standard__string__Object__to_s]))(var232) /* to_s on */; +var205 = ((val*(*)(val* self))(var177->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var177); /* native_to_s on */ } +varonce176 = var177; { -nit___nit__AbstractCompilerVisitor___add_decl(var_v, var235); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var205); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } } BREAK_label: (void)0; -var236 = 1; { -var237 = standard___standard__Int___Discrete__successor(var_i, var236); +var206 = standard___standard__Int___Discrete__successor(var_i, 1l); } -var_i = var237; +var_i = var206; } else { -goto BREAK_label238; +goto BREAK_label207; } } -BREAK_label238: (void)0; -if (varonce239) { -var240 = varonce239; +BREAK_label207: (void)0; } else { -var241 = "}"; -var242 = 1; -var243 = standard___standard__NativeString___to_s_with_length(var241, var242); -var240 = var243; -varonce239 = var240; -} -{ -nit___nit__AbstractCompilerVisitor___add_decl(var_v, var240); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } -if (varonce244) { -var245 = varonce244; +if (likely(varonce208!=NULL)) { +var209 = varonce208; } else { -var246 = "};"; -var247 = 2; -var248 = standard___standard__NativeString___to_s_with_length(var246, var247); -var245 = var248; -varonce244 = var245; +var210 = "}"; +var211 = standard___standard__NativeString___to_s_with_length(var210, 1l); +var209 = var211; +varonce208 = var209; } { -nit___nit__AbstractCompilerVisitor___add_decl(var_v, var245); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var209); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } +if (likely(varonce212!=NULL)) { +var213 = varonce212; } else { +var214 = "};"; +var215 = standard___standard__NativeString___to_s_with_length(var214, 2l); +var213 = var215; +varonce212 = var213; } { -var250 = nit__abstract_compiler___MClassType___MType__ctype(var_mtype); +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var213); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } -if (varonce251) { -var252 = varonce251; } else { -var253 = "val*"; -var254 = 4; -var255 = standard___standard__NativeString___to_s_with_length(var253, var254); -var252 = var255; -varonce251 = var252; } { -{ /* Inline kernel#Object#!= (var250,var252) on */ -var_other = var252; -{ -var258 = ((short int (*)(val* self, val* p0))(var250->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var250, var_other) /* == on */; -} -var259 = !var258; -var256 = var259; -goto RET_LABEL257; -RET_LABEL257:(void)0; +var217 = nit__abstract_compiler___MClassType___MType__is_c_primitive(var_mtype); } -} -var_260 = var256; -if (var256){ -var249 = var_260; +var_218 = var217; +if (var217){ +var216 = var_218; } else { { { /* Inline model#MClassType#mclass (var_mtype) on */ -var263 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var263 == NULL)) { +var221 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var221 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1058); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138); +fatal_exit(1); } -var261 = var263; -RET_LABEL262:(void)0; +var219 = var221; +RET_LABEL220:(void)0; } } { -{ /* Inline model#MClass#name (var261) on */ -var266 = var261->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ -if (unlikely(var266 == NULL)) { +{ /* Inline model#MClass#name (var219) on */ +var224 = var219->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ +if (unlikely(var224 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 348); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 362); +fatal_exit(1); } -var264 = var266; -RET_LABEL265:(void)0; +var222 = var224; +RET_LABEL223:(void)0; } } -if (varonce267) { -var268 = varonce267; +if (likely(varonce225!=NULL)) { +var226 = varonce225; } else { -var269 = "Pointer"; -var270 = 7; -var271 = standard___standard__NativeString___to_s_with_length(var269, var270); -var268 = var271; -varonce267 = var268; +var227 = "Pointer"; +var228 = standard___standard__NativeString___to_s_with_length(var227, 7l); +var226 = var228; +varonce225 = var226; +} +{ +var229 = ((short int(*)(val* self, val* p0))(var222->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var222, var226); /* == on */ } +var216 = var229; +} +if (var216){ { -var272 = ((short int (*)(val* self, val* p0))(var264->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var264, var268) /* == on */; +{ /* Inline separate_compiler#MType#is_tagged (var_mtype) on */ +var232 = var_mtype->attrs[COLOR_nit__separate_compiler__MType___is_tagged].s; /* _is_tagged on */ +var230 = var232; +RET_LABEL231:(void)0; +} } -var249 = var272; +if (var230){ +goto RET_LABEL; +} else { } -if (var249){ { { /* Inline abstract_compiler#AbstractCompiler#header (self) on */ -var275 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ -if (unlikely(var275 == NULL)) { +var235 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var235 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 523); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 569); +fatal_exit(1); } -var273 = var275; -RET_LABEL274:(void)0; +var233 = var235; +RET_LABEL234:(void)0; } } -if (varonce276) { -var277 = varonce276; +if (unlikely(varonce236==NULL)) { +var237 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce238!=NULL)) { +var239 = varonce238; } else { -var278 = "struct instance_"; -var279 = 16; -var280 = standard___standard__NativeString___to_s_with_length(var278, var279); -var277 = var280; -varonce276 = var277; +var240 = "struct instance_"; +var241 = standard___standard__NativeString___to_s_with_length(var240, 16l); +var239 = var241; +varonce238 = var239; } -if (varonce281) { -var282 = varonce281; +((struct instance_standard__NativeArray*)var237)->values[0]=var239; +if (likely(varonce242!=NULL)) { +var243 = varonce242; } else { -var283 = " {"; -var284 = 2; -var285 = standard___standard__NativeString___to_s_with_length(var283, var284); -var282 = var285; -varonce281 = var282; -} -var286 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var286 = array_instance Array[Object] */ -var287 = 3; -var288 = NEW_standard__NativeArray(var287, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var288)->values[0] = (val*) var277; -((struct instance_standard__NativeArray*)var288)->values[1] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var288)->values[2] = (val*) var282; -{ -((void (*)(val* self, val* p0, long p1))(var286->class->vft[COLOR_standard__array__Array__with_native]))(var286, var288, var287) /* with_native on */; +var244 = " {"; +var245 = standard___standard__NativeString___to_s_with_length(var244, 2l); +var243 = var245; +varonce242 = var243; } +((struct instance_standard__NativeArray*)var237)->values[2]=var243; +} else { +var237 = varonce236; +varonce236 = NULL; } +((struct instance_standard__NativeArray*)var237)->values[1]=var_c_name; { -var289 = ((val* (*)(val* self))(var286->class->vft[COLOR_standard__string__Object__to_s]))(var286) /* to_s on */; +var246 = ((val*(*)(val* self))(var237->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var237); /* native_to_s on */ } +varonce236 = var237; { -nit___nit__CodeWriter___add_decl(var273, var289); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +nit___nit__CodeWriter___add_decl(var233, var246); /* Direct call abstract_compiler#CodeWriter#add_decl on */ } { { /* Inline abstract_compiler#AbstractCompiler#header (self) on */ -var292 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ -if (unlikely(var292 == NULL)) { +var249 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var249 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 523); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 569); +fatal_exit(1); } -var290 = var292; -RET_LABEL291:(void)0; +var247 = var249; +RET_LABEL248:(void)0; } } -if (varonce293) { -var294 = varonce293; +if (likely(varonce250!=NULL)) { +var251 = varonce250; } else { -var295 = "const struct type *type;"; -var296 = 24; -var297 = standard___standard__NativeString___to_s_with_length(var295, var296); -var294 = var297; -varonce293 = var294; +var252 = "const struct type *type;"; +var253 = standard___standard__NativeString___to_s_with_length(var252, 24l); +var251 = var253; +varonce250 = var251; } { -nit___nit__CodeWriter___add_decl(var290, var294); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +nit___nit__CodeWriter___add_decl(var247, var251); /* Direct call abstract_compiler#CodeWriter#add_decl on */ } { { /* Inline abstract_compiler#AbstractCompiler#header (self) on */ -var300 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ -if (unlikely(var300 == NULL)) { +var256 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var256 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 523); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 569); +fatal_exit(1); } -var298 = var300; -RET_LABEL299:(void)0; +var254 = var256; +RET_LABEL255:(void)0; } } -if (varonce301) { -var302 = varonce301; +if (likely(varonce257!=NULL)) { +var258 = varonce257; } else { -var303 = "const struct class *class;"; -var304 = 26; -var305 = standard___standard__NativeString___to_s_with_length(var303, var304); -var302 = var305; -varonce301 = var302; +var259 = "const struct class *class;"; +var260 = standard___standard__NativeString___to_s_with_length(var259, 26l); +var258 = var260; +varonce257 = var258; } { -nit___nit__CodeWriter___add_decl(var298, var302); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +nit___nit__CodeWriter___add_decl(var254, var258); /* Direct call abstract_compiler#CodeWriter#add_decl on */ } { { /* Inline abstract_compiler#AbstractCompiler#header (self) on */ -var308 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ -if (unlikely(var308 == NULL)) { +var263 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var263 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 523); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 569); +fatal_exit(1); } -var306 = var308; -RET_LABEL307:(void)0; +var261 = var263; +RET_LABEL262:(void)0; } } -{ -var309 = nit__abstract_compiler___MClassType___MType__ctype_extern(var_mtype); +if (unlikely(varonce264==NULL)) { +var265 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce266!=NULL)) { +var267 = varonce266; +} else { +var268 = " value;"; +var269 = standard___standard__NativeString___to_s_with_length(var268, 7l); +var267 = var269; +varonce266 = var267; } -if (varonce310) { -var311 = varonce310; +((struct instance_standard__NativeArray*)var265)->values[1]=var267; } else { -var312 = " value;"; -var313 = 7; -var314 = standard___standard__NativeString___to_s_with_length(var312, var313); -var311 = var314; -varonce310 = var311; +var265 = varonce264; +varonce264 = NULL; } -var315 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var315 = array_instance Array[Object] */ -var316 = 2; -var317 = NEW_standard__NativeArray(var316, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var317)->values[0] = (val*) var309; -((struct instance_standard__NativeArray*)var317)->values[1] = (val*) var311; { -((void (*)(val* self, val* p0, long p1))(var315->class->vft[COLOR_standard__array__Array__with_native]))(var315, var317, var316) /* with_native on */; -} +var270 = nit__abstract_compiler___MClassType___MType__ctype_extern(var_mtype); } +((struct instance_standard__NativeArray*)var265)->values[0]=var270; { -var318 = ((val* (*)(val* self))(var315->class->vft[COLOR_standard__string__Object__to_s]))(var315) /* to_s on */; +var271 = ((val*(*)(val* self))(var265->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var265); /* native_to_s on */ } +varonce264 = var265; { -nit___nit__CodeWriter___add_decl(var306, var318); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +nit___nit__CodeWriter___add_decl(var261, var271); /* Direct call abstract_compiler#CodeWriter#add_decl on */ } { { /* Inline abstract_compiler#AbstractCompiler#header (self) on */ -var321 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ -if (unlikely(var321 == NULL)) { +var274 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var274 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 523); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 569); +fatal_exit(1); } -var319 = var321; -RET_LABEL320:(void)0; +var272 = var274; +RET_LABEL273:(void)0; } } -if (varonce322) { -var323 = varonce322; +if (likely(varonce275!=NULL)) { +var276 = varonce275; } else { -var324 = "};"; -var325 = 2; -var326 = standard___standard__NativeString___to_s_with_length(var324, var325); -var323 = var326; -varonce322 = var323; +var277 = "};"; +var278 = standard___standard__NativeString___to_s_with_length(var277, 2l); +var276 = var278; +varonce275 = var276; } { -nit___nit__CodeWriter___add_decl(var319, var323); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +nit___nit__CodeWriter___add_decl(var272, var276); /* Direct call abstract_compiler#CodeWriter#add_decl on */ } if (var_rta == NULL) { PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 727); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 864); +fatal_exit(1); } else { { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_types (var_rta) on */ if (unlikely(var_rta == NULL)) { PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 53); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 60); +fatal_exit(1); } -var330 = var_rta->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on */ -if (unlikely(var330 == NULL)) { +var282 = var_rta->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on */ +if (unlikely(var282 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 53); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 60); +fatal_exit(1); } -var328 = var330; -RET_LABEL329:(void)0; +var280 = var282; +RET_LABEL281:(void)0; } } { -var331 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var328, var_mtype); +var283 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var280, var_mtype); } -var332 = !var331; -var_333 = var332; -if (var332){ +var284 = !var283; +var_285 = var284; +if (var284){ { { /* Inline model#MClassType#mclass (var_mtype) on */ -var336 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var336 == NULL)) { +var288 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var288 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1058); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138); +fatal_exit(1); } -var334 = var336; -RET_LABEL335:(void)0; +var286 = var288; +RET_LABEL287:(void)0; } } { -{ /* Inline model#MClass#name (var334) on */ -var339 = var334->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ -if (unlikely(var339 == NULL)) { +{ /* Inline model#MClass#name (var286) on */ +var291 = var286->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ +if (unlikely(var291 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 348); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 362); +fatal_exit(1); } -var337 = var339; -RET_LABEL338:(void)0; +var289 = var291; +RET_LABEL290:(void)0; } } -if (varonce340) { -var341 = varonce340; +if (likely(varonce292!=NULL)) { +var293 = varonce292; } else { -var342 = "Pointer"; -var343 = 7; -var344 = standard___standard__NativeString___to_s_with_length(var342, var343); -var341 = var344; -varonce340 = var341; +var294 = "Pointer"; +var295 = standard___standard__NativeString___to_s_with_length(var294, 7l); +var293 = var295; +varonce292 = var293; } { -{ /* Inline kernel#Object#!= (var337,var341) on */ -var_other = var341; +{ /* Inline kernel#Object#!= (var289,var293) on */ +var_other = var293; { -var347 = ((short int (*)(val* self, val* p0))(var337->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var337, var_other) /* == on */; +var298 = ((short int(*)(val* self, val* p0))(var289->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var289, var_other); /* == on */ } -var348 = !var347; -var345 = var348; -goto RET_LABEL346; -RET_LABEL346:(void)0; +var299 = !var298; +var296 = var299; +goto RET_LABEL297; +RET_LABEL297:(void)0; } } -var327 = var345; +var279 = var296; } else { -var327 = var_333; +var279 = var_285; } -if (var327){ +if (var279){ goto RET_LABEL; } else { } -if (varonce349) { -var350 = varonce349; +if (unlikely(varonce300==NULL)) { +var301 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce302!=NULL)) { +var303 = varonce302; } else { -var351 = "BOX_"; -var352 = 4; -var353 = standard___standard__NativeString___to_s_with_length(var351, var352); -var350 = var353; -varonce349 = var350; -} -var354 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var354 = array_instance Array[Object] */ -var355 = 2; -var356 = NEW_standard__NativeArray(var355, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var356)->values[0] = (val*) var350; -((struct instance_standard__NativeArray*)var356)->values[1] = (val*) var_c_name; -{ -((void (*)(val* self, val* p0, long p1))(var354->class->vft[COLOR_standard__array__Array__with_native]))(var354, var356, var355) /* with_native on */; +var304 = "BOX_"; +var305 = standard___standard__NativeString___to_s_with_length(var304, 4l); +var303 = var305; +varonce302 = var303; } +((struct instance_standard__NativeArray*)var301)->values[0]=var303; +} else { +var301 = varonce300; +varonce300 = NULL; } +((struct instance_standard__NativeArray*)var301)->values[1]=var_c_name; { -var357 = ((val* (*)(val* self))(var354->class->vft[COLOR_standard__string__Object__to_s]))(var354) /* to_s on */; +var306 = ((val*(*)(val* self))(var301->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var301); /* native_to_s on */ } -if (varonce358) { -var359 = varonce358; +varonce300 = var301; +if (unlikely(varonce307==NULL)) { +var308 = NEW_standard__NativeArray(5l, &type_standard__NativeArray__standard__String); +if (likely(varonce309!=NULL)) { +var310 = varonce309; } else { -var360 = "val* BOX_"; -var361 = 9; -var362 = standard___standard__NativeString___to_s_with_length(var360, var361); -var359 = var362; -varonce358 = var359; +var311 = "val* BOX_"; +var312 = standard___standard__NativeString___to_s_with_length(var311, 9l); +var310 = var312; +varonce309 = var310; } -if (varonce363) { -var364 = varonce363; +((struct instance_standard__NativeArray*)var308)->values[0]=var310; +if (likely(varonce313!=NULL)) { +var314 = varonce313; } else { -var365 = "("; -var366 = 1; -var367 = standard___standard__NativeString___to_s_with_length(var365, var366); -var364 = var367; -varonce363 = var364; +var315 = "("; +var316 = standard___standard__NativeString___to_s_with_length(var315, 1l); +var314 = var316; +varonce313 = var314; } -{ -var368 = nit__abstract_compiler___MClassType___MType__ctype_extern(var_mtype); +((struct instance_standard__NativeArray*)var308)->values[2]=var314; +if (likely(varonce317!=NULL)) { +var318 = varonce317; +} else { +var319 = ");"; +var320 = standard___standard__NativeString___to_s_with_length(var319, 2l); +var318 = var320; +varonce317 = var318; } -if (varonce369) { -var370 = varonce369; +((struct instance_standard__NativeArray*)var308)->values[4]=var318; } else { -var371 = ");"; -var372 = 2; -var373 = standard___standard__NativeString___to_s_with_length(var371, var372); -var370 = var373; -varonce369 = var370; +var308 = varonce307; +varonce307 = NULL; } -var374 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var374 = array_instance Array[Object] */ -var375 = 5; -var376 = NEW_standard__NativeArray(var375, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var376)->values[0] = (val*) var359; -((struct instance_standard__NativeArray*)var376)->values[1] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var376)->values[2] = (val*) var364; -((struct instance_standard__NativeArray*)var376)->values[3] = (val*) var368; -((struct instance_standard__NativeArray*)var376)->values[4] = (val*) var370; +((struct instance_standard__NativeArray*)var308)->values[1]=var_c_name; { -((void (*)(val* self, val* p0, long p1))(var374->class->vft[COLOR_standard__array__Array__with_native]))(var374, var376, var375) /* with_native on */; -} +var321 = nit__abstract_compiler___MClassType___MType__ctype_extern(var_mtype); } +((struct instance_standard__NativeArray*)var308)->values[3]=var321; { -var377 = ((val* (*)(val* self))(var374->class->vft[COLOR_standard__string__Object__to_s]))(var374) /* to_s on */; +var322 = ((val*(*)(val* self))(var308->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var308); /* native_to_s on */ } +varonce307 = var308; { -nit___nit__AbstractCompiler___provide_declaration(self, var357, var377); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ +nit___nit__AbstractCompiler___provide_declaration(self, var306, var322); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ +} +if (unlikely(varonce323==NULL)) { +var324 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce325!=NULL)) { +var326 = varonce325; +} else { +var327 = "/* allocate "; +var328 = standard___standard__NativeString___to_s_with_length(var327, 12l); +var326 = var328; +varonce325 = var326; } -if (varonce378) { -var379 = varonce378; +((struct instance_standard__NativeArray*)var324)->values[0]=var326; +if (likely(varonce329!=NULL)) { +var330 = varonce329; } else { -var380 = "/* allocate "; -var381 = 12; -var382 = standard___standard__NativeString___to_s_with_length(var380, var381); -var379 = var382; -varonce378 = var379; +var331 = " */"; +var332 = standard___standard__NativeString___to_s_with_length(var331, 3l); +var330 = var332; +varonce329 = var330; } -if (varonce383) { -var384 = varonce383; +((struct instance_standard__NativeArray*)var324)->values[2]=var330; } else { -var385 = " */"; -var386 = 3; -var387 = standard___standard__NativeString___to_s_with_length(var385, var386); -var384 = var387; -varonce383 = var384; +var324 = varonce323; +varonce323 = NULL; } -var388 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var388 = array_instance Array[Object] */ -var389 = 3; -var390 = NEW_standard__NativeArray(var389, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var390)->values[0] = (val*) var379; -((struct instance_standard__NativeArray*)var390)->values[1] = (val*) var_mtype; -((struct instance_standard__NativeArray*)var390)->values[2] = (val*) var384; { -((void (*)(val* self, val* p0, long p1))(var388->class->vft[COLOR_standard__array__Array__with_native]))(var388, var390, var389) /* with_native on */; -} +var333 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_standard__string__Object__to_s]))(var_mtype); /* to_s on */ } +((struct instance_standard__NativeArray*)var324)->values[1]=var333; { -var391 = ((val* (*)(val* self))(var388->class->vft[COLOR_standard__string__Object__to_s]))(var388) /* to_s on */; +var334 = ((val*(*)(val* self))(var324->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var324); /* native_to_s on */ } +varonce323 = var324; { -nit___nit__AbstractCompilerVisitor___add_decl(var_v, var391); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var334); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } -if (varonce392) { -var393 = varonce392; +if (unlikely(varonce335==NULL)) { +var336 = NEW_standard__NativeArray(5l, &type_standard__NativeArray__standard__String); +if (likely(varonce337!=NULL)) { +var338 = varonce337; } else { -var394 = "val* BOX_"; -var395 = 9; -var396 = standard___standard__NativeString___to_s_with_length(var394, var395); -var393 = var396; -varonce392 = var393; +var339 = "val* BOX_"; +var340 = standard___standard__NativeString___to_s_with_length(var339, 9l); +var338 = var340; +varonce337 = var338; } -{ -var397 = ((val* (*)(val* self))(var_mtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_mtype) /* c_name on */; -} -if (varonce398) { -var399 = varonce398; +((struct instance_standard__NativeArray*)var336)->values[0]=var338; +if (likely(varonce341!=NULL)) { +var342 = varonce341; } else { -var400 = "("; -var401 = 1; -var402 = standard___standard__NativeString___to_s_with_length(var400, var401); -var399 = var402; -varonce398 = var399; +var343 = "("; +var344 = standard___standard__NativeString___to_s_with_length(var343, 1l); +var342 = var344; +varonce341 = var342; } -{ -var403 = nit__abstract_compiler___MClassType___MType__ctype_extern(var_mtype); +((struct instance_standard__NativeArray*)var336)->values[2]=var342; +if (likely(varonce345!=NULL)) { +var346 = varonce345; +} else { +var347 = " value) {"; +var348 = standard___standard__NativeString___to_s_with_length(var347, 9l); +var346 = var348; +varonce345 = var346; } -if (varonce404) { -var405 = varonce404; +((struct instance_standard__NativeArray*)var336)->values[4]=var346; } else { -var406 = " value) {"; -var407 = 9; -var408 = standard___standard__NativeString___to_s_with_length(var406, var407); -var405 = var408; -varonce404 = var405; +var336 = varonce335; +varonce335 = NULL; } -var409 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var409 = array_instance Array[Object] */ -var410 = 5; -var411 = NEW_standard__NativeArray(var410, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var411)->values[0] = (val*) var393; -((struct instance_standard__NativeArray*)var411)->values[1] = (val*) var397; -((struct instance_standard__NativeArray*)var411)->values[2] = (val*) var399; -((struct instance_standard__NativeArray*)var411)->values[3] = (val*) var403; -((struct instance_standard__NativeArray*)var411)->values[4] = (val*) var405; { -((void (*)(val* self, val* p0, long p1))(var409->class->vft[COLOR_standard__array__Array__with_native]))(var409, var411, var410) /* with_native on */; +var349 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_mtype); /* c_name on */ } +((struct instance_standard__NativeArray*)var336)->values[1]=var349; +{ +var350 = nit__abstract_compiler___MClassType___MType__ctype_extern(var_mtype); } +((struct instance_standard__NativeArray*)var336)->values[3]=var350; { -var412 = ((val* (*)(val* self))(var409->class->vft[COLOR_standard__string__Object__to_s]))(var409) /* to_s on */; +var351 = ((val*(*)(val* self))(var336->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var336); /* native_to_s on */ } +varonce335 = var336; { -nit___nit__AbstractCompilerVisitor___add_decl(var_v, var412); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var351); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } -if (varonce413) { -var414 = varonce413; +if (unlikely(varonce352==NULL)) { +var353 = NEW_standard__NativeArray(5l, &type_standard__NativeArray__standard__String); +if (likely(varonce354!=NULL)) { +var355 = varonce354; } else { -var415 = "struct instance_"; -var416 = 16; -var417 = standard___standard__NativeString___to_s_with_length(var415, var416); -var414 = var417; -varonce413 = var414; +var356 = "struct instance_"; +var357 = standard___standard__NativeString___to_s_with_length(var356, 16l); +var355 = var357; +varonce354 = var355; } -if (varonce418) { -var419 = varonce418; +((struct instance_standard__NativeArray*)var353)->values[0]=var355; +if (likely(varonce358!=NULL)) { +var359 = varonce358; } else { -var420 = "*res = nit_alloc(sizeof(struct instance_"; -var421 = 40; -var422 = standard___standard__NativeString___to_s_with_length(var420, var421); -var419 = var422; -varonce418 = var419; +var360 = "*res = nit_alloc(sizeof(struct instance_"; +var361 = standard___standard__NativeString___to_s_with_length(var360, 40l); +var359 = var361; +varonce358 = var359; } -if (varonce423) { -var424 = varonce423; +((struct instance_standard__NativeArray*)var353)->values[2]=var359; +if (likely(varonce362!=NULL)) { +var363 = varonce362; } else { -var425 = "));"; -var426 = 3; -var427 = standard___standard__NativeString___to_s_with_length(var425, var426); -var424 = var427; -varonce423 = var424; -} -var428 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var428 = array_instance Array[Object] */ -var429 = 5; -var430 = NEW_standard__NativeArray(var429, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var430)->values[0] = (val*) var414; -((struct instance_standard__NativeArray*)var430)->values[1] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var430)->values[2] = (val*) var419; -((struct instance_standard__NativeArray*)var430)->values[3] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var430)->values[4] = (val*) var424; -{ -((void (*)(val* self, val* p0, long p1))(var428->class->vft[COLOR_standard__array__Array__with_native]))(var428, var430, var429) /* with_native on */; +var364 = "));"; +var365 = standard___standard__NativeString___to_s_with_length(var364, 3l); +var363 = var365; +varonce362 = var363; } +((struct instance_standard__NativeArray*)var353)->values[4]=var363; +} else { +var353 = varonce352; +varonce352 = NULL; } +((struct instance_standard__NativeArray*)var353)->values[1]=var_c_name; +((struct instance_standard__NativeArray*)var353)->values[3]=var_c_name; { -var431 = ((val* (*)(val* self))(var428->class->vft[COLOR_standard__string__Object__to_s]))(var428) /* to_s on */; +var366 = ((val*(*)(val* self))(var353->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var353); /* native_to_s on */ } +varonce352 = var353; { -nit___nit__AbstractCompilerVisitor___add(var_v, var431); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var366); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } { { /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (var_v) on */ -var434 = var_v->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ -if (unlikely(var434 == NULL)) { +var369 = var_v->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ +if (unlikely(var369 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1059); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1102); +fatal_exit(1); } -var432 = var434; -RET_LABEL433:(void)0; +var367 = var369; +RET_LABEL368:(void)0; } } { -{ /* Inline separate_compiler#SeparateCompiler#undead_types (var432) on */ -var437 = var432->attrs[COLOR_nit__separate_compiler__SeparateCompiler___undead_types].val; /* _undead_types on */ -if (unlikely(var437 == NULL)) { +{ /* Inline separate_compiler#SeparateCompiler#undead_types (var367) on */ +var372 = var367->attrs[COLOR_nit__separate_compiler__SeparateCompiler___undead_types].val; /* _undead_types on */ +if (unlikely(var372 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _undead_types"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 121); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 146); +fatal_exit(1); } -var435 = var437; -RET_LABEL436:(void)0; +var370 = var372; +RET_LABEL371:(void)0; } } { -((void (*)(val* self, val* p0))(var435->class->vft[COLOR_standard__abstract_collection__SimpleCollection__add]))(var435, var_mtype) /* add on */; +((void(*)(val* self, val* p0))((((long)var370&3)?class_info[((long)var370&3)]:var370->class)->vft[COLOR_standard__abstract_collection__SimpleCollection__add]))(var370, var_mtype); /* add on */ } -if (varonce438) { -var439 = varonce438; +if (unlikely(varonce373==NULL)) { +var374 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce375!=NULL)) { +var376 = varonce375; } else { -var440 = "type_"; -var441 = 5; -var442 = standard___standard__NativeString___to_s_with_length(var440, var441); -var439 = var442; -varonce438 = var439; -} -var443 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var443 = array_instance Array[Object] */ -var444 = 2; -var445 = NEW_standard__NativeArray(var444, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var445)->values[0] = (val*) var439; -((struct instance_standard__NativeArray*)var445)->values[1] = (val*) var_c_name; -{ -((void (*)(val* self, val* p0, long p1))(var443->class->vft[COLOR_standard__array__Array__with_native]))(var443, var445, var444) /* with_native on */; +var377 = "type_"; +var378 = standard___standard__NativeString___to_s_with_length(var377, 5l); +var376 = var378; +varonce375 = var376; } +((struct instance_standard__NativeArray*)var374)->values[0]=var376; +} else { +var374 = varonce373; +varonce373 = NULL; } +((struct instance_standard__NativeArray*)var374)->values[1]=var_c_name; { -var446 = ((val* (*)(val* self))(var443->class->vft[COLOR_standard__string__Object__to_s]))(var443) /* to_s on */; +var379 = ((val*(*)(val* self))(var374->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var374); /* native_to_s on */ } +varonce373 = var374; { -nit___nit__AbstractCompilerVisitor___require_declaration(var_v, var446); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +nit___nit__AbstractCompilerVisitor___require_declaration(var_v, var379); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ } -if (varonce447) { -var448 = varonce447; +if (unlikely(varonce380==NULL)) { +var381 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce382!=NULL)) { +var383 = varonce382; } else { -var449 = "res->type = &type_"; -var450 = 18; -var451 = standard___standard__NativeString___to_s_with_length(var449, var450); -var448 = var451; -varonce447 = var448; +var384 = "res->type = &type_"; +var385 = standard___standard__NativeString___to_s_with_length(var384, 18l); +var383 = var385; +varonce382 = var383; } -if (varonce452) { -var453 = varonce452; +((struct instance_standard__NativeArray*)var381)->values[0]=var383; +if (likely(varonce386!=NULL)) { +var387 = varonce386; } else { -var454 = ";"; -var455 = 1; -var456 = standard___standard__NativeString___to_s_with_length(var454, var455); -var453 = var456; -varonce452 = var453; -} -var457 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var457 = array_instance Array[Object] */ -var458 = 3; -var459 = NEW_standard__NativeArray(var458, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var459)->values[0] = (val*) var448; -((struct instance_standard__NativeArray*)var459)->values[1] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var459)->values[2] = (val*) var453; -{ -((void (*)(val* self, val* p0, long p1))(var457->class->vft[COLOR_standard__array__Array__with_native]))(var457, var459, var458) /* with_native on */; +var388 = ";"; +var389 = standard___standard__NativeString___to_s_with_length(var388, 1l); +var387 = var389; +varonce386 = var387; } +((struct instance_standard__NativeArray*)var381)->values[2]=var387; +} else { +var381 = varonce380; +varonce380 = NULL; } +((struct instance_standard__NativeArray*)var381)->values[1]=var_c_name; { -var460 = ((val* (*)(val* self))(var457->class->vft[COLOR_standard__string__Object__to_s]))(var457) /* to_s on */; +var390 = ((val*(*)(val* self))(var381->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var381); /* native_to_s on */ } +varonce380 = var381; { -nit___nit__AbstractCompilerVisitor___add(var_v, var460); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var390); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce461) { -var462 = varonce461; +if (unlikely(varonce391==NULL)) { +var392 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce393!=NULL)) { +var394 = varonce393; } else { -var463 = "class_"; -var464 = 6; -var465 = standard___standard__NativeString___to_s_with_length(var463, var464); -var462 = var465; -varonce461 = var462; -} -var466 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var466 = array_instance Array[Object] */ -var467 = 2; -var468 = NEW_standard__NativeArray(var467, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var468)->values[0] = (val*) var462; -((struct instance_standard__NativeArray*)var468)->values[1] = (val*) var_c_name; -{ -((void (*)(val* self, val* p0, long p1))(var466->class->vft[COLOR_standard__array__Array__with_native]))(var466, var468, var467) /* with_native on */; +var395 = "class_"; +var396 = standard___standard__NativeString___to_s_with_length(var395, 6l); +var394 = var396; +varonce393 = var394; } +((struct instance_standard__NativeArray*)var392)->values[0]=var394; +} else { +var392 = varonce391; +varonce391 = NULL; } +((struct instance_standard__NativeArray*)var392)->values[1]=var_c_name; { -var469 = ((val* (*)(val* self))(var466->class->vft[COLOR_standard__string__Object__to_s]))(var466) /* to_s on */; +var397 = ((val*(*)(val* self))(var392->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var392); /* native_to_s on */ } +varonce391 = var392; { -nit___nit__AbstractCompilerVisitor___require_declaration(var_v, var469); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +nit___nit__AbstractCompilerVisitor___require_declaration(var_v, var397); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ } -if (varonce470) { -var471 = varonce470; +if (unlikely(varonce398==NULL)) { +var399 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce400!=NULL)) { +var401 = varonce400; } else { -var472 = "res->class = &class_"; -var473 = 20; -var474 = standard___standard__NativeString___to_s_with_length(var472, var473); -var471 = var474; -varonce470 = var471; +var402 = "res->class = &class_"; +var403 = standard___standard__NativeString___to_s_with_length(var402, 20l); +var401 = var403; +varonce400 = var401; } -if (varonce475) { -var476 = varonce475; +((struct instance_standard__NativeArray*)var399)->values[0]=var401; +if (likely(varonce404!=NULL)) { +var405 = varonce404; } else { -var477 = ";"; -var478 = 1; -var479 = standard___standard__NativeString___to_s_with_length(var477, var478); -var476 = var479; -varonce475 = var476; -} -var480 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var480 = array_instance Array[Object] */ -var481 = 3; -var482 = NEW_standard__NativeArray(var481, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var482)->values[0] = (val*) var471; -((struct instance_standard__NativeArray*)var482)->values[1] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var482)->values[2] = (val*) var476; -{ -((void (*)(val* self, val* p0, long p1))(var480->class->vft[COLOR_standard__array__Array__with_native]))(var480, var482, var481) /* with_native on */; +var406 = ";"; +var407 = standard___standard__NativeString___to_s_with_length(var406, 1l); +var405 = var407; +varonce404 = var405; } +((struct instance_standard__NativeArray*)var399)->values[2]=var405; +} else { +var399 = varonce398; +varonce398 = NULL; } +((struct instance_standard__NativeArray*)var399)->values[1]=var_c_name; { -var483 = ((val* (*)(val* self))(var480->class->vft[COLOR_standard__string__Object__to_s]))(var480) /* to_s on */; +var408 = ((val*(*)(val* self))(var399->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var399); /* native_to_s on */ } +varonce398 = var399; { -nit___nit__AbstractCompilerVisitor___add(var_v, var483); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var408); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce484) { -var485 = varonce484; +if (likely(varonce409!=NULL)) { +var410 = varonce409; } else { -var486 = "res->value = value;"; -var487 = 19; -var488 = standard___standard__NativeString___to_s_with_length(var486, var487); -var485 = var488; -varonce484 = var485; +var411 = "res->value = value;"; +var412 = standard___standard__NativeString___to_s_with_length(var411, 19l); +var410 = var412; +varonce409 = var410; } { -nit___nit__AbstractCompilerVisitor___add(var_v, var485); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var410); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce489) { -var490 = varonce489; +if (likely(varonce413!=NULL)) { +var414 = varonce413; } else { -var491 = "return (val*)res;"; -var492 = 17; -var493 = standard___standard__NativeString___to_s_with_length(var491, var492); -var490 = var493; -varonce489 = var490; +var415 = "return (val*)res;"; +var416 = standard___standard__NativeString___to_s_with_length(var415, 17l); +var414 = var416; +varonce413 = var414; } { -nit___nit__AbstractCompilerVisitor___add(var_v, var490); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var414); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce494) { -var495 = varonce494; +if (likely(varonce417!=NULL)) { +var418 = varonce417; } else { -var496 = "}"; -var497 = 1; -var498 = standard___standard__NativeString___to_s_with_length(var496, var497); -var495 = var498; -varonce494 = var495; +var419 = "}"; +var420 = standard___standard__NativeString___to_s_with_length(var419, 1l); +var418 = var420; +varonce417 = var418; } { -nit___nit__AbstractCompilerVisitor___add(var_v, var495); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var418); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } { { /* Inline model#MClassType#mclass (var_mtype) on */ -var501 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var501 == NULL)) { +var423 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var423 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1058); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138); +fatal_exit(1); } -var499 = var501; -RET_LABEL500:(void)0; +var421 = var423; +RET_LABEL422:(void)0; } } { -{ /* Inline model#MClass#name (var499) on */ -var504 = var499->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ -if (unlikely(var504 == NULL)) { +{ /* Inline model#MClass#name (var421) on */ +var426 = var421->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ +if (unlikely(var426 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 348); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 362); +fatal_exit(1); } -var502 = var504; -RET_LABEL503:(void)0; +var424 = var426; +RET_LABEL425:(void)0; } } -if (varonce505) { -var506 = varonce505; +if (likely(varonce427!=NULL)) { +var428 = varonce427; } else { -var507 = "Pointer"; -var508 = 7; -var509 = standard___standard__NativeString___to_s_with_length(var507, var508); -var506 = var509; -varonce505 = var506; +var429 = "Pointer"; +var430 = standard___standard__NativeString___to_s_with_length(var429, 7l); +var428 = var430; +varonce427 = var428; } { -{ /* Inline kernel#Object#!= (var502,var506) on */ -var_other = var506; +{ /* Inline kernel#Object#!= (var424,var428) on */ +var_other = var428; { -var512 = ((short int (*)(val* self, val* p0))(var502->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var502, var_other) /* == on */; +var433 = ((short int(*)(val* self, val* p0))(var424->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var424, var_other); /* == on */ } -var513 = !var512; -var510 = var513; -goto RET_LABEL511; -RET_LABEL511:(void)0; +var434 = !var433; +var431 = var434; +goto RET_LABEL432; +RET_LABEL432:(void)0; } } -if (var510){ +if (var431){ goto RET_LABEL; } else { } { -var514 = ((val* (*)(val* self))(self->class->vft[COLOR_nit__abstract_compiler__AbstractCompiler__new_visitor]))(self) /* new_visitor on */; +var435 = ((val*(*)(val* self))(self->class->vft[COLOR_nit__abstract_compiler__AbstractCompiler__new_visitor]))(self); /* new_visitor on */ } -var_v = var514; -if (varonce515) { -var516 = varonce515; +var_v = var435; +if (unlikely(varonce436==NULL)) { +var437 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce438!=NULL)) { +var439 = varonce438; } else { -var517 = "NEW_"; -var518 = 4; -var519 = standard___standard__NativeString___to_s_with_length(var517, var518); -var516 = var519; -varonce515 = var516; -} -var520 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var520 = array_instance Array[Object] */ -var521 = 2; -var522 = NEW_standard__NativeArray(var521, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var522)->values[0] = (val*) var516; -((struct instance_standard__NativeArray*)var522)->values[1] = (val*) var_c_name; -{ -((void (*)(val* self, val* p0, long p1))(var520->class->vft[COLOR_standard__array__Array__with_native]))(var520, var522, var521) /* with_native on */; +var440 = "NEW_"; +var441 = standard___standard__NativeString___to_s_with_length(var440, 4l); +var439 = var441; +varonce438 = var439; } +((struct instance_standard__NativeArray*)var437)->values[0]=var439; +} else { +var437 = varonce436; +varonce436 = NULL; } +((struct instance_standard__NativeArray*)var437)->values[1]=var_c_name; { -var523 = ((val* (*)(val* self))(var520->class->vft[COLOR_standard__string__Object__to_s]))(var520) /* to_s on */; +var442 = ((val*(*)(val* self))(var437->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var437); /* native_to_s on */ } -{ -var524 = nit__abstract_compiler___MClassType___MType__ctype(var_mtype); +varonce436 = var437; +if (unlikely(varonce443==NULL)) { +var444 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce445!=NULL)) { +var446 = varonce445; +} else { +var447 = " NEW_"; +var448 = standard___standard__NativeString___to_s_with_length(var447, 5l); +var446 = var448; +varonce445 = var446; } -if (varonce525) { -var526 = varonce525; +((struct instance_standard__NativeArray*)var444)->values[1]=var446; +if (likely(varonce449!=NULL)) { +var450 = varonce449; } else { -var527 = " NEW_"; -var528 = 5; -var529 = standard___standard__NativeString___to_s_with_length(var527, var528); -var526 = var529; -varonce525 = var526; +var451 = "(const struct type* type);"; +var452 = standard___standard__NativeString___to_s_with_length(var451, 26l); +var450 = var452; +varonce449 = var450; } -if (varonce530) { -var531 = varonce530; +((struct instance_standard__NativeArray*)var444)->values[3]=var450; } else { -var532 = "(const struct type* type);"; -var533 = 26; -var534 = standard___standard__NativeString___to_s_with_length(var532, var533); -var531 = var534; -varonce530 = var531; +var444 = varonce443; +varonce443 = NULL; } -var535 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var535 = array_instance Array[Object] */ -var536 = 4; -var537 = NEW_standard__NativeArray(var536, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var537)->values[0] = (val*) var524; -((struct instance_standard__NativeArray*)var537)->values[1] = (val*) var526; -((struct instance_standard__NativeArray*)var537)->values[2] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var537)->values[3] = (val*) var531; { -((void (*)(val* self, val* p0, long p1))(var535->class->vft[COLOR_standard__array__Array__with_native]))(var535, var537, var536) /* with_native on */; -} +var453 = nit__abstract_compiler___MClassType___MType__ctype(var_mtype); } +((struct instance_standard__NativeArray*)var444)->values[0]=var453; +((struct instance_standard__NativeArray*)var444)->values[2]=var_c_name; { -var538 = ((val* (*)(val* self))(var535->class->vft[COLOR_standard__string__Object__to_s]))(var535) /* to_s on */; +var454 = ((val*(*)(val* self))(var444->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var444); /* native_to_s on */ } +varonce443 = var444; { -nit___nit__AbstractCompiler___provide_declaration(self, var523, var538); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ +nit___nit__AbstractCompiler___provide_declaration(self, var442, var454); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ } -if (varonce539) { -var540 = varonce539; +if (unlikely(varonce455==NULL)) { +var456 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce457!=NULL)) { +var458 = varonce457; } else { -var541 = "/* allocate "; -var542 = 12; -var543 = standard___standard__NativeString___to_s_with_length(var541, var542); -var540 = var543; -varonce539 = var540; +var459 = "/* allocate "; +var460 = standard___standard__NativeString___to_s_with_length(var459, 12l); +var458 = var460; +varonce457 = var458; } -if (varonce544) { -var545 = varonce544; +((struct instance_standard__NativeArray*)var456)->values[0]=var458; +if (likely(varonce461!=NULL)) { +var462 = varonce461; } else { -var546 = " */"; -var547 = 3; -var548 = standard___standard__NativeString___to_s_with_length(var546, var547); -var545 = var548; -varonce544 = var545; -} -var549 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var549 = array_instance Array[Object] */ -var550 = 3; -var551 = NEW_standard__NativeArray(var550, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var551)->values[0] = (val*) var540; -((struct instance_standard__NativeArray*)var551)->values[1] = (val*) var_mtype; -((struct instance_standard__NativeArray*)var551)->values[2] = (val*) var545; -{ -((void (*)(val* self, val* p0, long p1))(var549->class->vft[COLOR_standard__array__Array__with_native]))(var549, var551, var550) /* with_native on */; +var463 = " */"; +var464 = standard___standard__NativeString___to_s_with_length(var463, 3l); +var462 = var464; +varonce461 = var462; } +((struct instance_standard__NativeArray*)var456)->values[2]=var462; +} else { +var456 = varonce455; +varonce455 = NULL; } { -var552 = ((val* (*)(val* self))(var549->class->vft[COLOR_standard__string__Object__to_s]))(var549) /* to_s on */; +var465 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_standard__string__Object__to_s]))(var_mtype); /* to_s on */ } +((struct instance_standard__NativeArray*)var456)->values[1]=var465; { -nit___nit__AbstractCompilerVisitor___add_decl(var_v, var552); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +var466 = ((val*(*)(val* self))(var456->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var456); /* native_to_s on */ } +varonce455 = var456; { -var553 = nit__abstract_compiler___MClassType___MType__ctype(var_mtype); +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var466); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } -if (varonce554) { -var555 = varonce554; +if (unlikely(varonce467==NULL)) { +var468 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce469!=NULL)) { +var470 = varonce469; } else { -var556 = " NEW_"; -var557 = 5; -var558 = standard___standard__NativeString___to_s_with_length(var556, var557); -var555 = var558; -varonce554 = var555; +var471 = " NEW_"; +var472 = standard___standard__NativeString___to_s_with_length(var471, 5l); +var470 = var472; +varonce469 = var470; } -if (varonce559) { -var560 = varonce559; +((struct instance_standard__NativeArray*)var468)->values[1]=var470; +if (likely(varonce473!=NULL)) { +var474 = varonce473; } else { -var561 = "(const struct type* type) {"; -var562 = 27; -var563 = standard___standard__NativeString___to_s_with_length(var561, var562); -var560 = var563; -varonce559 = var560; +var475 = "(const struct type* type) {"; +var476 = standard___standard__NativeString___to_s_with_length(var475, 27l); +var474 = var476; +varonce473 = var474; } -var564 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var564 = array_instance Array[Object] */ -var565 = 4; -var566 = NEW_standard__NativeArray(var565, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var566)->values[0] = (val*) var553; -((struct instance_standard__NativeArray*)var566)->values[1] = (val*) var555; -((struct instance_standard__NativeArray*)var566)->values[2] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var566)->values[3] = (val*) var560; -{ -((void (*)(val* self, val* p0, long p1))(var564->class->vft[COLOR_standard__array__Array__with_native]))(var564, var566, var565) /* with_native on */; +((struct instance_standard__NativeArray*)var468)->values[3]=var474; +} else { +var468 = varonce467; +varonce467 = NULL; } +{ +var477 = nit__abstract_compiler___MClassType___MType__ctype(var_mtype); } +((struct instance_standard__NativeArray*)var468)->values[0]=var477; +((struct instance_standard__NativeArray*)var468)->values[2]=var_c_name; { -var567 = ((val* (*)(val* self))(var564->class->vft[COLOR_standard__string__Object__to_s]))(var564) /* to_s on */; +var478 = ((val*(*)(val* self))(var468->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var468); /* native_to_s on */ } +varonce467 = var468; { -nit___nit__AbstractCompilerVisitor___add_decl(var_v, var567); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var478); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } if (var_is_dead){ -if (varonce568) { -var569 = varonce568; +if (unlikely(varonce479==NULL)) { +var480 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce481!=NULL)) { +var482 = varonce481; } else { -var570 = " is DEAD"; -var571 = 8; -var572 = standard___standard__NativeString___to_s_with_length(var570, var571); -var569 = var572; -varonce568 = var569; +var483 = " is DEAD"; +var484 = standard___standard__NativeString___to_s_with_length(var483, 8l); +var482 = var484; +varonce481 = var482; } -var573 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var573 = array_instance Array[Object] */ -var574 = 2; -var575 = NEW_standard__NativeArray(var574, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var575)->values[0] = (val*) var_mclass; -((struct instance_standard__NativeArray*)var575)->values[1] = (val*) var569; -{ -((void (*)(val* self, val* p0, long p1))(var573->class->vft[COLOR_standard__array__Array__with_native]))(var573, var575, var574) /* with_native on */; +((struct instance_standard__NativeArray*)var480)->values[1]=var482; +} else { +var480 = varonce479; +varonce479 = NULL; } +{ +var485 = ((val*(*)(val* self))(var_mclass->class->vft[COLOR_standard__string__Object__to_s]))(var_mclass); /* to_s on */ } +((struct instance_standard__NativeArray*)var480)->values[0]=var485; { -var576 = ((val* (*)(val* self))(var573->class->vft[COLOR_standard__string__Object__to_s]))(var573) /* to_s on */; +var486 = ((val*(*)(val* self))(var480->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var480); /* native_to_s on */ } +varonce479 = var480; { -nit___nit__AbstractCompilerVisitor___add_abort(var_v, var576); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_abort on */ +nit___nit__AbstractCompilerVisitor___add_abort(var_v, var486); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_abort on */ } } else { -if (varonce577) { -var578 = varonce577; +if (likely(varonce487!=NULL)) { +var488 = varonce487; } else { -var579 = "self"; -var580 = 4; -var581 = standard___standard__NativeString___to_s_with_length(var579, var580); -var578 = var581; -varonce577 = var578; +var489 = "self"; +var490 = standard___standard__NativeString___to_s_with_length(var489, 4l); +var488 = var490; +varonce487 = var488; } { -var582 = nit___nit__AbstractCompilerVisitor___new_named_var(var_v, var_mtype, var578); +var491 = nit___nit__AbstractCompilerVisitor___new_named_var(var_v, var_mtype, var488); } -var_res = var582; -var583 = 1; +var_res = var491; { -{ /* Inline abstract_compiler#RuntimeVariable#is_exact= (var_res,var583) on */ -var_res->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___is_exact].s = var583; /* _is_exact on */ -RET_LABEL584:(void)0; +{ /* Inline abstract_compiler#RuntimeVariable#is_exact= (var_res,1) on */ +var_res->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___is_exact].s = 1; /* _is_exact on */ +RET_LABEL492:(void)0; } } -if (varonce585) { -var586 = varonce585; +if (unlikely(varonce493==NULL)) { +var494 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce495!=NULL)) { +var496 = varonce495; } else { -var587 = " = nit_alloc(sizeof(struct instance_"; -var588 = 36; -var589 = standard___standard__NativeString___to_s_with_length(var587, var588); -var586 = var589; -varonce585 = var586; +var497 = " = nit_alloc(sizeof(struct instance_"; +var498 = standard___standard__NativeString___to_s_with_length(var497, 36l); +var496 = var498; +varonce495 = var496; } -{ -var590 = ((val* (*)(val* self))(var_mtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_mtype) /* c_name on */; +((struct instance_standard__NativeArray*)var494)->values[1]=var496; +if (likely(varonce499!=NULL)) { +var500 = varonce499; +} else { +var501 = "));"; +var502 = standard___standard__NativeString___to_s_with_length(var501, 3l); +var500 = var502; +varonce499 = var500; } -if (varonce591) { -var592 = varonce591; +((struct instance_standard__NativeArray*)var494)->values[3]=var500; } else { -var593 = "));"; -var594 = 3; -var595 = standard___standard__NativeString___to_s_with_length(var593, var594); -var592 = var595; -varonce591 = var592; +var494 = varonce493; +varonce493 = NULL; } -var596 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var596 = array_instance Array[Object] */ -var597 = 4; -var598 = NEW_standard__NativeArray(var597, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var598)->values[0] = (val*) var_res; -((struct instance_standard__NativeArray*)var598)->values[1] = (val*) var586; -((struct instance_standard__NativeArray*)var598)->values[2] = (val*) var590; -((struct instance_standard__NativeArray*)var598)->values[3] = (val*) var592; { -((void (*)(val* self, val* p0, long p1))(var596->class->vft[COLOR_standard__array__Array__with_native]))(var596, var598, var597) /* with_native on */; +var503 = ((val*(*)(val* self))(var_res->class->vft[COLOR_standard__string__Object__to_s]))(var_res); /* to_s on */ } +((struct instance_standard__NativeArray*)var494)->values[0]=var503; +{ +var504 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_mtype); /* c_name on */ } +((struct instance_standard__NativeArray*)var494)->values[2]=var504; { -var599 = ((val* (*)(val* self))(var596->class->vft[COLOR_standard__string__Object__to_s]))(var596) /* to_s on */; +var505 = ((val*(*)(val* self))(var494->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var494); /* native_to_s on */ } +varonce493 = var494; { -nit___nit__AbstractCompilerVisitor___add(var_v, var599); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var505); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce600) { -var601 = varonce600; +if (unlikely(varonce506==NULL)) { +var507 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce508!=NULL)) { +var509 = varonce508; } else { -var602 = "->type = type;"; -var603 = 14; -var604 = standard___standard__NativeString___to_s_with_length(var602, var603); -var601 = var604; -varonce600 = var601; +var510 = "->type = type;"; +var511 = standard___standard__NativeString___to_s_with_length(var510, 14l); +var509 = var511; +varonce508 = var509; } -var605 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var605 = array_instance Array[Object] */ -var606 = 2; -var607 = NEW_standard__NativeArray(var606, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var607)->values[0] = (val*) var_res; -((struct instance_standard__NativeArray*)var607)->values[1] = (val*) var601; -{ -((void (*)(val* self, val* p0, long p1))(var605->class->vft[COLOR_standard__array__Array__with_native]))(var605, var607, var606) /* with_native on */; +((struct instance_standard__NativeArray*)var507)->values[1]=var509; +} else { +var507 = varonce506; +varonce506 = NULL; } +{ +var512 = ((val*(*)(val* self))(var_res->class->vft[COLOR_standard__string__Object__to_s]))(var_res); /* to_s on */ } +((struct instance_standard__NativeArray*)var507)->values[0]=var512; { -var608 = ((val* (*)(val* self))(var605->class->vft[COLOR_standard__string__Object__to_s]))(var605) /* to_s on */; +var513 = ((val*(*)(val* self))(var507->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var507); /* native_to_s on */ } +varonce506 = var507; { -nit___nit__AbstractCompilerVisitor___add(var_v, var608); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var513); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce609) { -var610 = varonce609; +if (likely(varonce514!=NULL)) { +var515 = varonce514; } else { -var611 = "type"; -var612 = 4; -var613 = standard___standard__NativeString___to_s_with_length(var611, var612); -var610 = var613; -varonce609 = var610; +var516 = "type"; +var517 = standard___standard__NativeString___to_s_with_length(var516, 4l); +var515 = var517; +varonce514 = var515; } { -nit___nit__SeparateCompiler___hardening_live_type(self, var_v, var610); /* Direct call separate_compiler#SeparateCompiler#hardening_live_type on */ +nit___nit__SeparateCompiler___hardening_live_type(self, var_v, var515); /* Direct call separate_compiler#SeparateCompiler#hardening_live_type on */ } -if (varonce614) { -var615 = varonce614; +if (unlikely(varonce518==NULL)) { +var519 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce520!=NULL)) { +var521 = varonce520; } else { -var616 = "class_"; -var617 = 6; -var618 = standard___standard__NativeString___to_s_with_length(var616, var617); -var615 = var618; -varonce614 = var615; -} -var619 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var619 = array_instance Array[Object] */ -var620 = 2; -var621 = NEW_standard__NativeArray(var620, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var621)->values[0] = (val*) var615; -((struct instance_standard__NativeArray*)var621)->values[1] = (val*) var_c_name; -{ -((void (*)(val* self, val* p0, long p1))(var619->class->vft[COLOR_standard__array__Array__with_native]))(var619, var621, var620) /* with_native on */; +var522 = "class_"; +var523 = standard___standard__NativeString___to_s_with_length(var522, 6l); +var521 = var523; +varonce520 = var521; } +((struct instance_standard__NativeArray*)var519)->values[0]=var521; +} else { +var519 = varonce518; +varonce518 = NULL; } +((struct instance_standard__NativeArray*)var519)->values[1]=var_c_name; { -var622 = ((val* (*)(val* self))(var619->class->vft[COLOR_standard__string__Object__to_s]))(var619) /* to_s on */; +var524 = ((val*(*)(val* self))(var519->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var519); /* native_to_s on */ } +varonce518 = var519; { -nit___nit__AbstractCompilerVisitor___require_declaration(var_v, var622); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +nit___nit__AbstractCompilerVisitor___require_declaration(var_v, var524); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ } -if (varonce623) { -var624 = varonce623; +if (unlikely(varonce525==NULL)) { +var526 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce527!=NULL)) { +var528 = varonce527; } else { -var625 = "->class = &class_"; -var626 = 17; -var627 = standard___standard__NativeString___to_s_with_length(var625, var626); -var624 = var627; -varonce623 = var624; +var529 = "->class = &class_"; +var530 = standard___standard__NativeString___to_s_with_length(var529, 17l); +var528 = var530; +varonce527 = var528; } -if (varonce628) { -var629 = varonce628; +((struct instance_standard__NativeArray*)var526)->values[1]=var528; +if (likely(varonce531!=NULL)) { +var532 = varonce531; } else { -var630 = ";"; -var631 = 1; -var632 = standard___standard__NativeString___to_s_with_length(var630, var631); -var629 = var632; -varonce628 = var629; +var533 = ";"; +var534 = standard___standard__NativeString___to_s_with_length(var533, 1l); +var532 = var534; +varonce531 = var532; } -var633 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var633 = array_instance Array[Object] */ -var634 = 4; -var635 = NEW_standard__NativeArray(var634, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var635)->values[0] = (val*) var_res; -((struct instance_standard__NativeArray*)var635)->values[1] = (val*) var624; -((struct instance_standard__NativeArray*)var635)->values[2] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var635)->values[3] = (val*) var629; -{ -((void (*)(val* self, val* p0, long p1))(var633->class->vft[COLOR_standard__array__Array__with_native]))(var633, var635, var634) /* with_native on */; +((struct instance_standard__NativeArray*)var526)->values[3]=var532; +} else { +var526 = varonce525; +varonce525 = NULL; } +{ +var535 = ((val*(*)(val* self))(var_res->class->vft[COLOR_standard__string__Object__to_s]))(var_res); /* to_s on */ } +((struct instance_standard__NativeArray*)var526)->values[0]=var535; +((struct instance_standard__NativeArray*)var526)->values[2]=var_c_name; { -var636 = ((val* (*)(val* self))(var633->class->vft[COLOR_standard__string__Object__to_s]))(var633) /* to_s on */; +var536 = ((val*(*)(val* self))(var526->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var526); /* native_to_s on */ } +varonce525 = var526; { -nit___nit__AbstractCompilerVisitor___add(var_v, var636); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var536); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce637) { -var638 = varonce637; +if (unlikely(varonce537==NULL)) { +var538 = NEW_standard__NativeArray(5l, &type_standard__NativeArray__standard__String); +if (likely(varonce539!=NULL)) { +var540 = varonce539; } else { -var639 = "((struct instance_"; -var640 = 18; -var641 = standard___standard__NativeString___to_s_with_length(var639, var640); -var638 = var641; -varonce637 = var638; +var541 = "((struct instance_"; +var542 = standard___standard__NativeString___to_s_with_length(var541, 18l); +var540 = var542; +varonce539 = var540; } -{ -var642 = ((val* (*)(val* self))(var_mtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_mtype) /* c_name on */; +((struct instance_standard__NativeArray*)var538)->values[0]=var540; +if (likely(varonce543!=NULL)) { +var544 = varonce543; +} else { +var545 = "*)"; +var546 = standard___standard__NativeString___to_s_with_length(var545, 2l); +var544 = var546; +varonce543 = var544; } -if (varonce643) { -var644 = varonce643; +((struct instance_standard__NativeArray*)var538)->values[2]=var544; +if (likely(varonce547!=NULL)) { +var548 = varonce547; } else { -var645 = "*)"; -var646 = 2; -var647 = standard___standard__NativeString___to_s_with_length(var645, var646); -var644 = var647; -varonce643 = var644; +var549 = ")->value = NULL;"; +var550 = standard___standard__NativeString___to_s_with_length(var549, 16l); +var548 = var550; +varonce547 = var548; } -if (varonce648) { -var649 = varonce648; +((struct instance_standard__NativeArray*)var538)->values[4]=var548; } else { -var650 = ")->value = NULL;"; -var651 = 16; -var652 = standard___standard__NativeString___to_s_with_length(var650, var651); -var649 = var652; -varonce648 = var649; +var538 = varonce537; +varonce537 = NULL; } -var653 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var653 = array_instance Array[Object] */ -var654 = 5; -var655 = NEW_standard__NativeArray(var654, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var655)->values[0] = (val*) var638; -((struct instance_standard__NativeArray*)var655)->values[1] = (val*) var642; -((struct instance_standard__NativeArray*)var655)->values[2] = (val*) var644; -((struct instance_standard__NativeArray*)var655)->values[3] = (val*) var_res; -((struct instance_standard__NativeArray*)var655)->values[4] = (val*) var649; { -((void (*)(val* self, val* p0, long p1))(var653->class->vft[COLOR_standard__array__Array__with_native]))(var653, var655, var654) /* with_native on */; +var551 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_mtype); /* c_name on */ } +((struct instance_standard__NativeArray*)var538)->values[1]=var551; +{ +var552 = ((val*(*)(val* self))(var_res->class->vft[COLOR_standard__string__Object__to_s]))(var_res); /* to_s on */ } +((struct instance_standard__NativeArray*)var538)->values[3]=var552; { -var656 = ((val* (*)(val* self))(var653->class->vft[COLOR_standard__string__Object__to_s]))(var653) /* to_s on */; +var553 = ((val*(*)(val* self))(var538->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var538); /* native_to_s on */ } +varonce537 = var538; { -nit___nit__AbstractCompilerVisitor___add(var_v, var656); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var553); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce657) { -var658 = varonce657; +if (unlikely(varonce554==NULL)) { +var555 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce556!=NULL)) { +var557 = varonce556; } else { -var659 = "return "; -var660 = 7; -var661 = standard___standard__NativeString___to_s_with_length(var659, var660); -var658 = var661; -varonce657 = var658; +var558 = "return "; +var559 = standard___standard__NativeString___to_s_with_length(var558, 7l); +var557 = var559; +varonce556 = var557; } -if (varonce662) { -var663 = varonce662; +((struct instance_standard__NativeArray*)var555)->values[0]=var557; +if (likely(varonce560!=NULL)) { +var561 = varonce560; } else { -var664 = ";"; -var665 = 1; -var666 = standard___standard__NativeString___to_s_with_length(var664, var665); -var663 = var666; -varonce662 = var663; +var562 = ";"; +var563 = standard___standard__NativeString___to_s_with_length(var562, 1l); +var561 = var563; +varonce560 = var561; } -var667 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var667 = array_instance Array[Object] */ -var668 = 3; -var669 = NEW_standard__NativeArray(var668, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var669)->values[0] = (val*) var658; -((struct instance_standard__NativeArray*)var669)->values[1] = (val*) var_res; -((struct instance_standard__NativeArray*)var669)->values[2] = (val*) var663; -{ -((void (*)(val* self, val* p0, long p1))(var667->class->vft[COLOR_standard__array__Array__with_native]))(var667, var669, var668) /* with_native on */; +((struct instance_standard__NativeArray*)var555)->values[2]=var561; +} else { +var555 = varonce554; +varonce554 = NULL; } +{ +var564 = ((val*(*)(val* self))(var_res->class->vft[COLOR_standard__string__Object__to_s]))(var_res); /* to_s on */ } +((struct instance_standard__NativeArray*)var555)->values[1]=var564; { -var670 = ((val* (*)(val* self))(var667->class->vft[COLOR_standard__string__Object__to_s]))(var667) /* to_s on */; +var565 = ((val*(*)(val* self))(var555->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var555); /* native_to_s on */ } +varonce554 = var555; { -nit___nit__AbstractCompilerVisitor___add(var_v, var670); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var565); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } } -if (varonce671) { -var672 = varonce671; +if (likely(varonce566!=NULL)) { +var567 = varonce566; } else { -var673 = "}"; -var674 = 1; -var675 = standard___standard__NativeString___to_s_with_length(var673, var674); -var672 = var675; -varonce671 = var672; +var568 = "}"; +var569 = standard___standard__NativeString___to_s_with_length(var568, 1l); +var567 = var569; +varonce566 = var567; } { -nit___nit__AbstractCompilerVisitor___add(var_v, var672); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var567); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } goto RET_LABEL; } else { { { /* Inline model#MClass#name (var_mclass) on */ -var678 = var_mclass->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ -if (unlikely(var678 == NULL)) { +var572 = var_mclass->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ +if (unlikely(var572 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 348); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 362); +fatal_exit(1); } -var676 = var678; -RET_LABEL677:(void)0; +var570 = var572; +RET_LABEL571:(void)0; } } -if (varonce679) { -var680 = varonce679; +if (likely(varonce573!=NULL)) { +var574 = varonce573; } else { -var681 = "NativeArray"; -var682 = 11; -var683 = standard___standard__NativeString___to_s_with_length(var681, var682); -var680 = var683; -varonce679 = var680; +var575 = "NativeArray"; +var576 = standard___standard__NativeString___to_s_with_length(var575, 11l); +var574 = var576; +varonce573 = var574; } { -var684 = ((short int (*)(val* self, val* p0))(var676->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var676, var680) /* == on */; +var577 = ((short int(*)(val* self, val* p0))(var570->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var570, var574); /* == on */ } -if (var684){ +if (var577){ { { /* Inline abstract_compiler#AbstractCompiler#header (self) on */ -var687 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ -if (unlikely(var687 == NULL)) { +var580 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var580 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 523); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 569); +fatal_exit(1); } -var685 = var687; -RET_LABEL686:(void)0; +var578 = var580; +RET_LABEL579:(void)0; } } -if (varonce688) { -var689 = varonce688; +if (unlikely(varonce581==NULL)) { +var582 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce583!=NULL)) { +var584 = varonce583; } else { -var690 = "struct instance_"; -var691 = 16; -var692 = standard___standard__NativeString___to_s_with_length(var690, var691); -var689 = var692; -varonce688 = var689; +var585 = "struct instance_"; +var586 = standard___standard__NativeString___to_s_with_length(var585, 16l); +var584 = var586; +varonce583 = var584; } -if (varonce693) { -var694 = varonce693; +((struct instance_standard__NativeArray*)var582)->values[0]=var584; +if (likely(varonce587!=NULL)) { +var588 = varonce587; } else { -var695 = " {"; -var696 = 2; -var697 = standard___standard__NativeString___to_s_with_length(var695, var696); -var694 = var697; -varonce693 = var694; -} -var698 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var698 = array_instance Array[Object] */ -var699 = 3; -var700 = NEW_standard__NativeArray(var699, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var700)->values[0] = (val*) var689; -((struct instance_standard__NativeArray*)var700)->values[1] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var700)->values[2] = (val*) var694; -{ -((void (*)(val* self, val* p0, long p1))(var698->class->vft[COLOR_standard__array__Array__with_native]))(var698, var700, var699) /* with_native on */; +var589 = " {"; +var590 = standard___standard__NativeString___to_s_with_length(var589, 2l); +var588 = var590; +varonce587 = var588; } +((struct instance_standard__NativeArray*)var582)->values[2]=var588; +} else { +var582 = varonce581; +varonce581 = NULL; } +((struct instance_standard__NativeArray*)var582)->values[1]=var_c_name; { -var701 = ((val* (*)(val* self))(var698->class->vft[COLOR_standard__string__Object__to_s]))(var698) /* to_s on */; +var591 = ((val*(*)(val* self))(var582->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var582); /* native_to_s on */ } +varonce581 = var582; { -nit___nit__CodeWriter___add_decl(var685, var701); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +nit___nit__CodeWriter___add_decl(var578, var591); /* Direct call abstract_compiler#CodeWriter#add_decl on */ } { { /* Inline abstract_compiler#AbstractCompiler#header (self) on */ -var704 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ -if (unlikely(var704 == NULL)) { +var594 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var594 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 523); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 569); +fatal_exit(1); } -var702 = var704; -RET_LABEL703:(void)0; +var592 = var594; +RET_LABEL593:(void)0; } } -if (varonce705) { -var706 = varonce705; +if (likely(varonce595!=NULL)) { +var596 = varonce595; } else { -var707 = "const struct type *type;"; -var708 = 24; -var709 = standard___standard__NativeString___to_s_with_length(var707, var708); -var706 = var709; -varonce705 = var706; +var597 = "const struct type *type;"; +var598 = standard___standard__NativeString___to_s_with_length(var597, 24l); +var596 = var598; +varonce595 = var596; } { -nit___nit__CodeWriter___add_decl(var702, var706); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +nit___nit__CodeWriter___add_decl(var592, var596); /* Direct call abstract_compiler#CodeWriter#add_decl on */ } { { /* Inline abstract_compiler#AbstractCompiler#header (self) on */ -var712 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ -if (unlikely(var712 == NULL)) { +var601 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var601 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 523); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 569); +fatal_exit(1); } -var710 = var712; -RET_LABEL711:(void)0; +var599 = var601; +RET_LABEL600:(void)0; } } -if (varonce713) { -var714 = varonce713; +if (likely(varonce602!=NULL)) { +var603 = varonce602; } else { -var715 = "const struct class *class;"; -var716 = 26; -var717 = standard___standard__NativeString___to_s_with_length(var715, var716); -var714 = var717; -varonce713 = var714; +var604 = "const struct class *class;"; +var605 = standard___standard__NativeString___to_s_with_length(var604, 26l); +var603 = var605; +varonce602 = var603; } { -nit___nit__CodeWriter___add_decl(var710, var714); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +nit___nit__CodeWriter___add_decl(var599, var603); /* Direct call abstract_compiler#CodeWriter#add_decl on */ } { { /* Inline abstract_compiler#AbstractCompiler#header (self) on */ -var720 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ -if (unlikely(var720 == NULL)) { +var608 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var608 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 523); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 569); +fatal_exit(1); } -var718 = var720; -RET_LABEL719:(void)0; +var606 = var608; +RET_LABEL607:(void)0; } } -if (varonce721) { -var722 = varonce721; +if (likely(varonce609!=NULL)) { +var610 = varonce609; } else { -var723 = "int length;"; -var724 = 11; -var725 = standard___standard__NativeString___to_s_with_length(var723, var724); -var722 = var725; -varonce721 = var722; +var611 = "int length;"; +var612 = standard___standard__NativeString___to_s_with_length(var611, 11l); +var610 = var612; +varonce609 = var610; } { -nit___nit__CodeWriter___add_decl(var718, var722); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +nit___nit__CodeWriter___add_decl(var606, var610); /* Direct call abstract_compiler#CodeWriter#add_decl on */ } { { /* Inline abstract_compiler#AbstractCompiler#header (self) on */ -var728 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ -if (unlikely(var728 == NULL)) { +var615 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var615 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 523); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 569); +fatal_exit(1); } -var726 = var728; -RET_LABEL727:(void)0; +var613 = var615; +RET_LABEL614:(void)0; } } -if (varonce729) { -var730 = varonce729; +if (likely(varonce616!=NULL)) { +var617 = varonce616; } else { -var731 = "val* values[0];"; -var732 = 15; -var733 = standard___standard__NativeString___to_s_with_length(var731, var732); -var730 = var733; -varonce729 = var730; +var618 = "val* values[0];"; +var619 = standard___standard__NativeString___to_s_with_length(var618, 15l); +var617 = var619; +varonce616 = var617; } { -nit___nit__CodeWriter___add_decl(var726, var730); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +nit___nit__CodeWriter___add_decl(var613, var617); /* Direct call abstract_compiler#CodeWriter#add_decl on */ } { { /* Inline abstract_compiler#AbstractCompiler#header (self) on */ -var736 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ -if (unlikely(var736 == NULL)) { +var622 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var622 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 523); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 569); +fatal_exit(1); } -var734 = var736; -RET_LABEL735:(void)0; +var620 = var622; +RET_LABEL621:(void)0; } } -if (varonce737) { -var738 = varonce737; +if (likely(varonce623!=NULL)) { +var624 = varonce623; } else { -var739 = "};"; -var740 = 2; -var741 = standard___standard__NativeString___to_s_with_length(var739, var740); -var738 = var741; -varonce737 = var738; +var625 = "};"; +var626 = standard___standard__NativeString___to_s_with_length(var625, 2l); +var624 = var626; +varonce623 = var624; } { -nit___nit__CodeWriter___add_decl(var734, var738); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +nit___nit__CodeWriter___add_decl(var620, var624); /* Direct call abstract_compiler#CodeWriter#add_decl on */ } -if (varonce742) { -var743 = varonce742; +if (unlikely(varonce627==NULL)) { +var628 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce629!=NULL)) { +var630 = varonce629; } else { -var744 = "NEW_"; -var745 = 4; -var746 = standard___standard__NativeString___to_s_with_length(var744, var745); -var743 = var746; -varonce742 = var743; -} -var747 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var747 = array_instance Array[Object] */ -var748 = 2; -var749 = NEW_standard__NativeArray(var748, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var749)->values[0] = (val*) var743; -((struct instance_standard__NativeArray*)var749)->values[1] = (val*) var_c_name; -{ -((void (*)(val* self, val* p0, long p1))(var747->class->vft[COLOR_standard__array__Array__with_native]))(var747, var749, var748) /* with_native on */; +var631 = "NEW_"; +var632 = standard___standard__NativeString___to_s_with_length(var631, 4l); +var630 = var632; +varonce629 = var630; } +((struct instance_standard__NativeArray*)var628)->values[0]=var630; +} else { +var628 = varonce627; +varonce627 = NULL; } +((struct instance_standard__NativeArray*)var628)->values[1]=var_c_name; { -var750 = ((val* (*)(val* self))(var747->class->vft[COLOR_standard__string__Object__to_s]))(var747) /* to_s on */; +var633 = ((val*(*)(val* self))(var628->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var628); /* native_to_s on */ } -{ -var751 = nit__abstract_compiler___MClassType___MType__ctype(var_mtype); +varonce627 = var628; +if (unlikely(varonce634==NULL)) { +var635 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce636!=NULL)) { +var637 = varonce636; +} else { +var638 = " NEW_"; +var639 = standard___standard__NativeString___to_s_with_length(var638, 5l); +var637 = var639; +varonce636 = var637; } -if (varonce752) { -var753 = varonce752; +((struct instance_standard__NativeArray*)var635)->values[1]=var637; +if (likely(varonce640!=NULL)) { +var641 = varonce640; } else { -var754 = " NEW_"; -var755 = 5; -var756 = standard___standard__NativeString___to_s_with_length(var754, var755); -var753 = var756; -varonce752 = var753; +var642 = "(int length, const struct type* type);"; +var643 = standard___standard__NativeString___to_s_with_length(var642, 38l); +var641 = var643; +varonce640 = var641; } -if (varonce757) { -var758 = varonce757; +((struct instance_standard__NativeArray*)var635)->values[3]=var641; } else { -var759 = "(int length, const struct type* type);"; -var760 = 38; -var761 = standard___standard__NativeString___to_s_with_length(var759, var760); -var758 = var761; -varonce757 = var758; +var635 = varonce634; +varonce634 = NULL; } -var762 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var762 = array_instance Array[Object] */ -var763 = 4; -var764 = NEW_standard__NativeArray(var763, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var764)->values[0] = (val*) var751; -((struct instance_standard__NativeArray*)var764)->values[1] = (val*) var753; -((struct instance_standard__NativeArray*)var764)->values[2] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var764)->values[3] = (val*) var758; { -((void (*)(val* self, val* p0, long p1))(var762->class->vft[COLOR_standard__array__Array__with_native]))(var762, var764, var763) /* with_native on */; -} +var644 = nit__abstract_compiler___MClassType___MType__ctype(var_mtype); } +((struct instance_standard__NativeArray*)var635)->values[0]=var644; +((struct instance_standard__NativeArray*)var635)->values[2]=var_c_name; { -var765 = ((val* (*)(val* self))(var762->class->vft[COLOR_standard__string__Object__to_s]))(var762) /* to_s on */; +var645 = ((val*(*)(val* self))(var635->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var635); /* native_to_s on */ } +varonce634 = var635; { -nit___nit__AbstractCompiler___provide_declaration(self, var750, var765); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ +nit___nit__AbstractCompiler___provide_declaration(self, var633, var645); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ +} +if (unlikely(varonce646==NULL)) { +var647 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce648!=NULL)) { +var649 = varonce648; +} else { +var650 = "/* allocate "; +var651 = standard___standard__NativeString___to_s_with_length(var650, 12l); +var649 = var651; +varonce648 = var649; } -if (varonce766) { -var767 = varonce766; +((struct instance_standard__NativeArray*)var647)->values[0]=var649; +if (likely(varonce652!=NULL)) { +var653 = varonce652; } else { -var768 = "/* allocate "; -var769 = 12; -var770 = standard___standard__NativeString___to_s_with_length(var768, var769); -var767 = var770; -varonce766 = var767; +var654 = " */"; +var655 = standard___standard__NativeString___to_s_with_length(var654, 3l); +var653 = var655; +varonce652 = var653; } -if (varonce771) { -var772 = varonce771; +((struct instance_standard__NativeArray*)var647)->values[2]=var653; } else { -var773 = " */"; -var774 = 3; -var775 = standard___standard__NativeString___to_s_with_length(var773, var774); -var772 = var775; -varonce771 = var772; +var647 = varonce646; +varonce646 = NULL; } -var776 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var776 = array_instance Array[Object] */ -var777 = 3; -var778 = NEW_standard__NativeArray(var777, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var778)->values[0] = (val*) var767; -((struct instance_standard__NativeArray*)var778)->values[1] = (val*) var_mtype; -((struct instance_standard__NativeArray*)var778)->values[2] = (val*) var772; { -((void (*)(val* self, val* p0, long p1))(var776->class->vft[COLOR_standard__array__Array__with_native]))(var776, var778, var777) /* with_native on */; -} +var656 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_standard__string__Object__to_s]))(var_mtype); /* to_s on */ } +((struct instance_standard__NativeArray*)var647)->values[1]=var656; { -var779 = ((val* (*)(val* self))(var776->class->vft[COLOR_standard__string__Object__to_s]))(var776) /* to_s on */; +var657 = ((val*(*)(val* self))(var647->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var647); /* native_to_s on */ } +varonce646 = var647; { -nit___nit__AbstractCompilerVisitor___add_decl(var_v, var779); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var657); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } -{ -var780 = nit__abstract_compiler___MClassType___MType__ctype(var_mtype); +if (unlikely(varonce658==NULL)) { +var659 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce660!=NULL)) { +var661 = varonce660; +} else { +var662 = " NEW_"; +var663 = standard___standard__NativeString___to_s_with_length(var662, 5l); +var661 = var663; +varonce660 = var661; } -if (varonce781) { -var782 = varonce781; +((struct instance_standard__NativeArray*)var659)->values[1]=var661; +if (likely(varonce664!=NULL)) { +var665 = varonce664; } else { -var783 = " NEW_"; -var784 = 5; -var785 = standard___standard__NativeString___to_s_with_length(var783, var784); -var782 = var785; -varonce781 = var782; +var666 = "(int length, const struct type* type) {"; +var667 = standard___standard__NativeString___to_s_with_length(var666, 39l); +var665 = var667; +varonce664 = var665; } -if (varonce786) { -var787 = varonce786; +((struct instance_standard__NativeArray*)var659)->values[3]=var665; } else { -var788 = "(int length, const struct type* type) {"; -var789 = 39; -var790 = standard___standard__NativeString___to_s_with_length(var788, var789); -var787 = var790; -varonce786 = var787; +var659 = varonce658; +varonce658 = NULL; } -var791 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var791 = array_instance Array[Object] */ -var792 = 4; -var793 = NEW_standard__NativeArray(var792, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var793)->values[0] = (val*) var780; -((struct instance_standard__NativeArray*)var793)->values[1] = (val*) var782; -((struct instance_standard__NativeArray*)var793)->values[2] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var793)->values[3] = (val*) var787; { -((void (*)(val* self, val* p0, long p1))(var791->class->vft[COLOR_standard__array__Array__with_native]))(var791, var793, var792) /* with_native on */; -} +var668 = nit__abstract_compiler___MClassType___MType__ctype(var_mtype); } +((struct instance_standard__NativeArray*)var659)->values[0]=var668; +((struct instance_standard__NativeArray*)var659)->values[2]=var_c_name; { -var794 = ((val* (*)(val* self))(var791->class->vft[COLOR_standard__string__Object__to_s]))(var791) /* to_s on */; +var669 = ((val*(*)(val* self))(var659->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var659); /* native_to_s on */ } +varonce658 = var659; { -nit___nit__AbstractCompilerVisitor___add_decl(var_v, var794); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var669); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } -if (varonce795) { -var796 = varonce795; +if (likely(varonce670!=NULL)) { +var671 = varonce670; } else { -var797 = "self"; -var798 = 4; -var799 = standard___standard__NativeString___to_s_with_length(var797, var798); -var796 = var799; -varonce795 = var796; +var672 = "self"; +var673 = standard___standard__NativeString___to_s_with_length(var672, 4l); +var671 = var673; +varonce670 = var671; } { -var800 = nit___nit__AbstractCompilerVisitor___get_name(var_v, var796); +var674 = nit___nit__AbstractCompilerVisitor___get_name(var_v, var671); } -var_res801 = var800; -if (varonce802) { -var803 = varonce802; +var_res675 = var674; +if (unlikely(varonce676==NULL)) { +var677 = NEW_standard__NativeArray(5l, &type_standard__NativeArray__standard__String); +if (likely(varonce678!=NULL)) { +var679 = varonce678; } else { -var804 = "struct instance_"; -var805 = 16; -var806 = standard___standard__NativeString___to_s_with_length(var804, var805); -var803 = var806; -varonce802 = var803; +var680 = "struct instance_"; +var681 = standard___standard__NativeString___to_s_with_length(var680, 16l); +var679 = var681; +varonce678 = var679; } -if (varonce807) { -var808 = varonce807; +((struct instance_standard__NativeArray*)var677)->values[0]=var679; +if (likely(varonce682!=NULL)) { +var683 = varonce682; } else { -var809 = " *"; -var810 = 2; -var811 = standard___standard__NativeString___to_s_with_length(var809, var810); -var808 = var811; -varonce807 = var808; +var684 = " *"; +var685 = standard___standard__NativeString___to_s_with_length(var684, 2l); +var683 = var685; +varonce682 = var683; } -if (varonce812) { -var813 = varonce812; +((struct instance_standard__NativeArray*)var677)->values[2]=var683; +if (likely(varonce686!=NULL)) { +var687 = varonce686; } else { -var814 = ";"; -var815 = 1; -var816 = standard___standard__NativeString___to_s_with_length(var814, var815); -var813 = var816; -varonce812 = var813; -} -var817 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var817 = array_instance Array[Object] */ -var818 = 5; -var819 = NEW_standard__NativeArray(var818, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var819)->values[0] = (val*) var803; -((struct instance_standard__NativeArray*)var819)->values[1] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var819)->values[2] = (val*) var808; -((struct instance_standard__NativeArray*)var819)->values[3] = (val*) var_res801; -((struct instance_standard__NativeArray*)var819)->values[4] = (val*) var813; -{ -((void (*)(val* self, val* p0, long p1))(var817->class->vft[COLOR_standard__array__Array__with_native]))(var817, var819, var818) /* with_native on */; +var688 = ";"; +var689 = standard___standard__NativeString___to_s_with_length(var688, 1l); +var687 = var689; +varonce686 = var687; } +((struct instance_standard__NativeArray*)var677)->values[4]=var687; +} else { +var677 = varonce676; +varonce676 = NULL; } +((struct instance_standard__NativeArray*)var677)->values[1]=var_c_name; +((struct instance_standard__NativeArray*)var677)->values[3]=var_res675; { -var820 = ((val* (*)(val* self))(var817->class->vft[COLOR_standard__string__Object__to_s]))(var817) /* to_s on */; +var690 = ((val*(*)(val* self))(var677->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var677); /* native_to_s on */ } +varonce676 = var677; { -nit___nit__AbstractCompilerVisitor___add_decl(var_v, var820); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var690); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } { -var821 = ((val* (*)(val* self))(var_mtype->class->vft[COLOR_nit__model__MClassType__arguments]))(var_mtype) /* arguments on */; +var691 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nit__model__MClassType__arguments]))(var_mtype); /* arguments on */ } { -var822 = standard___standard__SequenceRead___Collection__first(var821); +var692 = standard___standard__SequenceRead___Collection__first(var691); } -var_mtype_elt = var822; -if (varonce823) { -var824 = varonce823; +var_mtype_elt = var692; +if (unlikely(varonce693==NULL)) { +var694 = NEW_standard__NativeArray(6l, &type_standard__NativeArray__standard__String); +if (likely(varonce695!=NULL)) { +var696 = varonce695; } else { -var825 = " = nit_alloc(sizeof(struct instance_"; -var826 = 36; -var827 = standard___standard__NativeString___to_s_with_length(var825, var826); -var824 = var827; -varonce823 = var824; +var697 = " = nit_alloc(sizeof(struct instance_"; +var698 = standard___standard__NativeString___to_s_with_length(var697, 36l); +var696 = var698; +varonce695 = var696; } -if (varonce828) { -var829 = varonce828; +((struct instance_standard__NativeArray*)var694)->values[1]=var696; +if (likely(varonce699!=NULL)) { +var700 = varonce699; } else { -var830 = ") + length*sizeof("; -var831 = 18; -var832 = standard___standard__NativeString___to_s_with_length(var830, var831); -var829 = var832; -varonce828 = var829; +var701 = ") + length*sizeof("; +var702 = standard___standard__NativeString___to_s_with_length(var701, 18l); +var700 = var702; +varonce699 = var700; } -{ -var833 = ((val* (*)(val* self))(var_mtype_elt->class->vft[COLOR_nit__abstract_compiler__MType__ctype]))(var_mtype_elt) /* ctype on */; +((struct instance_standard__NativeArray*)var694)->values[3]=var700; +if (likely(varonce703!=NULL)) { +var704 = varonce703; +} else { +var705 = "));"; +var706 = standard___standard__NativeString___to_s_with_length(var705, 3l); +var704 = var706; +varonce703 = var704; } -if (varonce834) { -var835 = varonce834; +((struct instance_standard__NativeArray*)var694)->values[5]=var704; } else { -var836 = "));"; -var837 = 3; -var838 = standard___standard__NativeString___to_s_with_length(var836, var837); -var835 = var838; -varonce834 = var835; +var694 = varonce693; +varonce693 = NULL; } -var839 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var839 = array_instance Array[Object] */ -var840 = 6; -var841 = NEW_standard__NativeArray(var840, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var841)->values[0] = (val*) var_res801; -((struct instance_standard__NativeArray*)var841)->values[1] = (val*) var824; -((struct instance_standard__NativeArray*)var841)->values[2] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var841)->values[3] = (val*) var829; -((struct instance_standard__NativeArray*)var841)->values[4] = (val*) var833; -((struct instance_standard__NativeArray*)var841)->values[5] = (val*) var835; +((struct instance_standard__NativeArray*)var694)->values[0]=var_res675; +((struct instance_standard__NativeArray*)var694)->values[2]=var_c_name; { -((void (*)(val* self, val* p0, long p1))(var839->class->vft[COLOR_standard__array__Array__with_native]))(var839, var841, var840) /* with_native on */; -} +var707 = ((val*(*)(val* self))(var_mtype_elt->class->vft[COLOR_nit__abstract_compiler__MType__ctype]))(var_mtype_elt); /* ctype on */ } +((struct instance_standard__NativeArray*)var694)->values[4]=var707; { -var842 = ((val* (*)(val* self))(var839->class->vft[COLOR_standard__string__Object__to_s]))(var839) /* to_s on */; +var708 = ((val*(*)(val* self))(var694->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var694); /* native_to_s on */ } +varonce693 = var694; { -nit___nit__AbstractCompilerVisitor___add(var_v, var842); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var708); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce843) { -var844 = varonce843; +if (unlikely(varonce709==NULL)) { +var710 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce711!=NULL)) { +var712 = varonce711; } else { -var845 = "->type = type;"; -var846 = 14; -var847 = standard___standard__NativeString___to_s_with_length(var845, var846); -var844 = var847; -varonce843 = var844; -} -var848 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var848 = array_instance Array[Object] */ -var849 = 2; -var850 = NEW_standard__NativeArray(var849, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var850)->values[0] = (val*) var_res801; -((struct instance_standard__NativeArray*)var850)->values[1] = (val*) var844; -{ -((void (*)(val* self, val* p0, long p1))(var848->class->vft[COLOR_standard__array__Array__with_native]))(var848, var850, var849) /* with_native on */; +var713 = "->type = type;"; +var714 = standard___standard__NativeString___to_s_with_length(var713, 14l); +var712 = var714; +varonce711 = var712; } +((struct instance_standard__NativeArray*)var710)->values[1]=var712; +} else { +var710 = varonce709; +varonce709 = NULL; } +((struct instance_standard__NativeArray*)var710)->values[0]=var_res675; { -var851 = ((val* (*)(val* self))(var848->class->vft[COLOR_standard__string__Object__to_s]))(var848) /* to_s on */; +var715 = ((val*(*)(val* self))(var710->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var710); /* native_to_s on */ } +varonce709 = var710; { -nit___nit__AbstractCompilerVisitor___add(var_v, var851); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var715); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce852) { -var853 = varonce852; +if (likely(varonce716!=NULL)) { +var717 = varonce716; } else { -var854 = "type"; -var855 = 4; -var856 = standard___standard__NativeString___to_s_with_length(var854, var855); -var853 = var856; -varonce852 = var853; +var718 = "type"; +var719 = standard___standard__NativeString___to_s_with_length(var718, 4l); +var717 = var719; +varonce716 = var717; } { -nit___nit__SeparateCompiler___hardening_live_type(self, var_v, var853); /* Direct call separate_compiler#SeparateCompiler#hardening_live_type on */ +nit___nit__SeparateCompiler___hardening_live_type(self, var_v, var717); /* Direct call separate_compiler#SeparateCompiler#hardening_live_type on */ } -if (varonce857) { -var858 = varonce857; +if (unlikely(varonce720==NULL)) { +var721 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce722!=NULL)) { +var723 = varonce722; } else { -var859 = "class_"; -var860 = 6; -var861 = standard___standard__NativeString___to_s_with_length(var859, var860); -var858 = var861; -varonce857 = var858; -} -var862 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var862 = array_instance Array[Object] */ -var863 = 2; -var864 = NEW_standard__NativeArray(var863, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var864)->values[0] = (val*) var858; -((struct instance_standard__NativeArray*)var864)->values[1] = (val*) var_c_name; -{ -((void (*)(val* self, val* p0, long p1))(var862->class->vft[COLOR_standard__array__Array__with_native]))(var862, var864, var863) /* with_native on */; +var724 = "class_"; +var725 = standard___standard__NativeString___to_s_with_length(var724, 6l); +var723 = var725; +varonce722 = var723; } +((struct instance_standard__NativeArray*)var721)->values[0]=var723; +} else { +var721 = varonce720; +varonce720 = NULL; } +((struct instance_standard__NativeArray*)var721)->values[1]=var_c_name; { -var865 = ((val* (*)(val* self))(var862->class->vft[COLOR_standard__string__Object__to_s]))(var862) /* to_s on */; +var726 = ((val*(*)(val* self))(var721->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var721); /* native_to_s on */ } +varonce720 = var721; { -nit___nit__AbstractCompilerVisitor___require_declaration(var_v, var865); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +nit___nit__AbstractCompilerVisitor___require_declaration(var_v, var726); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ } -if (varonce866) { -var867 = varonce866; +if (unlikely(varonce727==NULL)) { +var728 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce729!=NULL)) { +var730 = varonce729; } else { -var868 = "->class = &class_"; -var869 = 17; -var870 = standard___standard__NativeString___to_s_with_length(var868, var869); -var867 = var870; -varonce866 = var867; +var731 = "->class = &class_"; +var732 = standard___standard__NativeString___to_s_with_length(var731, 17l); +var730 = var732; +varonce729 = var730; } -if (varonce871) { -var872 = varonce871; +((struct instance_standard__NativeArray*)var728)->values[1]=var730; +if (likely(varonce733!=NULL)) { +var734 = varonce733; } else { -var873 = ";"; -var874 = 1; -var875 = standard___standard__NativeString___to_s_with_length(var873, var874); -var872 = var875; -varonce871 = var872; -} -var876 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var876 = array_instance Array[Object] */ -var877 = 4; -var878 = NEW_standard__NativeArray(var877, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var878)->values[0] = (val*) var_res801; -((struct instance_standard__NativeArray*)var878)->values[1] = (val*) var867; -((struct instance_standard__NativeArray*)var878)->values[2] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var878)->values[3] = (val*) var872; -{ -((void (*)(val* self, val* p0, long p1))(var876->class->vft[COLOR_standard__array__Array__with_native]))(var876, var878, var877) /* with_native on */; +var735 = ";"; +var736 = standard___standard__NativeString___to_s_with_length(var735, 1l); +var734 = var736; +varonce733 = var734; } +((struct instance_standard__NativeArray*)var728)->values[3]=var734; +} else { +var728 = varonce727; +varonce727 = NULL; } +((struct instance_standard__NativeArray*)var728)->values[0]=var_res675; +((struct instance_standard__NativeArray*)var728)->values[2]=var_c_name; { -var879 = ((val* (*)(val* self))(var876->class->vft[COLOR_standard__string__Object__to_s]))(var876) /* to_s on */; +var737 = ((val*(*)(val* self))(var728->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var728); /* native_to_s on */ } +varonce727 = var728; { -nit___nit__AbstractCompilerVisitor___add(var_v, var879); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var737); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce880) { -var881 = varonce880; +if (unlikely(varonce738==NULL)) { +var739 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce740!=NULL)) { +var741 = varonce740; } else { -var882 = "->length = length;"; -var883 = 18; -var884 = standard___standard__NativeString___to_s_with_length(var882, var883); -var881 = var884; -varonce880 = var881; -} -var885 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var885 = array_instance Array[Object] */ -var886 = 2; -var887 = NEW_standard__NativeArray(var886, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var887)->values[0] = (val*) var_res801; -((struct instance_standard__NativeArray*)var887)->values[1] = (val*) var881; -{ -((void (*)(val* self, val* p0, long p1))(var885->class->vft[COLOR_standard__array__Array__with_native]))(var885, var887, var886) /* with_native on */; +var742 = "->length = length;"; +var743 = standard___standard__NativeString___to_s_with_length(var742, 18l); +var741 = var743; +varonce740 = var741; } +((struct instance_standard__NativeArray*)var739)->values[1]=var741; +} else { +var739 = varonce738; +varonce738 = NULL; } +((struct instance_standard__NativeArray*)var739)->values[0]=var_res675; { -var888 = ((val* (*)(val* self))(var885->class->vft[COLOR_standard__string__Object__to_s]))(var885) /* to_s on */; +var744 = ((val*(*)(val* self))(var739->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var739); /* native_to_s on */ } +varonce738 = var739; { -nit___nit__AbstractCompilerVisitor___add(var_v, var888); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var744); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce889) { -var890 = varonce889; +if (unlikely(varonce745==NULL)) { +var746 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce747!=NULL)) { +var748 = varonce747; } else { -var891 = "return (val*)"; -var892 = 13; -var893 = standard___standard__NativeString___to_s_with_length(var891, var892); -var890 = var893; -varonce889 = var890; +var749 = "return (val*)"; +var750 = standard___standard__NativeString___to_s_with_length(var749, 13l); +var748 = var750; +varonce747 = var748; } -if (varonce894) { -var895 = varonce894; +((struct instance_standard__NativeArray*)var746)->values[0]=var748; +if (likely(varonce751!=NULL)) { +var752 = varonce751; } else { -var896 = ";"; -var897 = 1; -var898 = standard___standard__NativeString___to_s_with_length(var896, var897); -var895 = var898; -varonce894 = var895; -} -var899 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var899 = array_instance Array[Object] */ -var900 = 3; -var901 = NEW_standard__NativeArray(var900, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var901)->values[0] = (val*) var890; -((struct instance_standard__NativeArray*)var901)->values[1] = (val*) var_res801; -((struct instance_standard__NativeArray*)var901)->values[2] = (val*) var895; -{ -((void (*)(val* self, val* p0, long p1))(var899->class->vft[COLOR_standard__array__Array__with_native]))(var899, var901, var900) /* with_native on */; +var753 = ";"; +var754 = standard___standard__NativeString___to_s_with_length(var753, 1l); +var752 = var754; +varonce751 = var752; } +((struct instance_standard__NativeArray*)var746)->values[2]=var752; +} else { +var746 = varonce745; +varonce745 = NULL; } +((struct instance_standard__NativeArray*)var746)->values[1]=var_res675; { -var902 = ((val* (*)(val* self))(var899->class->vft[COLOR_standard__string__Object__to_s]))(var899) /* to_s on */; +var755 = ((val*(*)(val* self))(var746->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var746); /* native_to_s on */ } +varonce745 = var746; { -nit___nit__AbstractCompilerVisitor___add(var_v, var902); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var755); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce903) { -var904 = varonce903; +if (likely(varonce756!=NULL)) { +var757 = varonce756; } else { -var905 = "}"; -var906 = 1; -var907 = standard___standard__NativeString___to_s_with_length(var905, var906); -var904 = var907; -varonce903 = var904; +var758 = "}"; +var759 = standard___standard__NativeString___to_s_with_length(var758, 1l); +var757 = var759; +varonce756 = var757; } { -nit___nit__AbstractCompilerVisitor___add(var_v, var904); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var757); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } goto RET_LABEL; } else { { { /* Inline model#MClassType#mclass (var_mtype) on */ -var911 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var911 == NULL)) { +var763 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var763 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1058); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138); +fatal_exit(1); } -var909 = var911; -RET_LABEL910:(void)0; +var761 = var763; +RET_LABEL762:(void)0; } } { -{ /* Inline model#MClass#kind (var909) on */ -var914 = var909->attrs[COLOR_nit__model__MClass___kind].val; /* _kind on */ -if (unlikely(var914 == NULL)) { +{ /* Inline model#MClass#kind (var761) on */ +var766 = var761->attrs[COLOR_nit__model__MClass___kind].val; /* _kind on */ +if (unlikely(var766 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _kind"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 399); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 436); +fatal_exit(1); } -var912 = var914; -RET_LABEL913:(void)0; +var764 = var766; +RET_LABEL765:(void)0; } } +var767 = glob_sys; { -var915 = nit__model___standard__Object___extern_kind(self); +var768 = nit__model___standard__Sys___extern_kind(var767); } { -{ /* Inline kernel#Object#== (var912,var915) on */ -var_other149 = var915; +{ /* Inline kernel#Object#== (var764,var768) on */ +var_other126 = var768; { -{ /* Inline kernel#Object#is_same_instance (var912,var_other149) on */ -var920 = var912 == var_other149; -var918 = var920; -goto RET_LABEL919; -RET_LABEL919:(void)0; +{ /* Inline kernel#Object#is_same_instance (var764,var_other126) on */ +var773 = var764 == var_other126; +var771 = var773; +goto RET_LABEL772; +RET_LABEL772:(void)0; } } -var916 = var918; -goto RET_LABEL917; -RET_LABEL917:(void)0; +var769 = var771; +goto RET_LABEL770; +RET_LABEL770:(void)0; } } -var_921 = var916; -if (var916){ +var_774 = var769; +if (var769){ { { /* Inline model#MClassType#mclass (var_mtype) on */ -var924 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var924 == NULL)) { +var777 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var777 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1058); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138); +fatal_exit(1); } -var922 = var924; -RET_LABEL923:(void)0; +var775 = var777; +RET_LABEL776:(void)0; } } { -{ /* Inline model#MClass#name (var922) on */ -var927 = var922->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ -if (unlikely(var927 == NULL)) { +{ /* Inline model#MClass#name (var775) on */ +var780 = var775->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ +if (unlikely(var780 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 348); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 362); +fatal_exit(1); } -var925 = var927; -RET_LABEL926:(void)0; +var778 = var780; +RET_LABEL779:(void)0; } } -if (varonce928) { -var929 = varonce928; +if (likely(varonce781!=NULL)) { +var782 = varonce781; } else { -var930 = "NativeString"; -var931 = 12; -var932 = standard___standard__NativeString___to_s_with_length(var930, var931); -var929 = var932; -varonce928 = var929; +var783 = "NativeString"; +var784 = standard___standard__NativeString___to_s_with_length(var783, 12l); +var782 = var784; +varonce781 = var782; } { -{ /* Inline kernel#Object#!= (var925,var929) on */ -var_other = var929; +{ /* Inline kernel#Object#!= (var778,var782) on */ +var_other = var782; { -var935 = ((short int (*)(val* self, val* p0))(var925->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var925, var_other) /* == on */; +var787 = ((short int(*)(val* self, val* p0))(var778->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var778, var_other); /* == on */ } -var936 = !var935; -var933 = var936; -goto RET_LABEL934; -RET_LABEL934:(void)0; +var788 = !var787; +var785 = var788; +goto RET_LABEL786; +RET_LABEL786:(void)0; } } -var908 = var933; +var760 = var785; } else { -var908 = var_921; +var760 = var_774; } -if (var908){ +if (var760){ { { /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ -var939 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ -if (unlikely(var939 == NULL)) { +var791 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var791 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); -show_backtrace(1); -} -var937 = var939; -RET_LABEL938:(void)0; -} -} -{ -var940 = nit__model___MModule___pointer_type(var937); -} -var_pointer_type = var940; -if (varonce941) { -var942 = varonce941; -} else { -var943 = "NEW_"; -var944 = 4; -var945 = standard___standard__NativeString___to_s_with_length(var943, var944); -var942 = var945; -varonce941 = var942; -} -var946 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var946 = array_instance Array[Object] */ -var947 = 2; -var948 = NEW_standard__NativeArray(var947, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var948)->values[0] = (val*) var942; -((struct instance_standard__NativeArray*)var948)->values[1] = (val*) var_c_name; -{ -((void (*)(val* self, val* p0, long p1))(var946->class->vft[COLOR_standard__array__Array__with_native]))(var946, var948, var947) /* with_native on */; +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 515); +fatal_exit(1); } +var789 = var791; +RET_LABEL790:(void)0; } -{ -var949 = ((val* (*)(val* self))(var946->class->vft[COLOR_standard__string__Object__to_s]))(var946) /* to_s on */; } { -var950 = nit__abstract_compiler___MClassType___MType__ctype(var_mtype); +var792 = nit__model___MModule___pointer_type(var789); } -if (varonce951) { -var952 = varonce951; +var_pointer_type = var792; +if (unlikely(varonce793==NULL)) { +var794 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce795!=NULL)) { +var796 = varonce795; } else { -var953 = " NEW_"; -var954 = 5; -var955 = standard___standard__NativeString___to_s_with_length(var953, var954); -var952 = var955; -varonce951 = var952; +var797 = "NEW_"; +var798 = standard___standard__NativeString___to_s_with_length(var797, 4l); +var796 = var798; +varonce795 = var796; } -if (varonce956) { -var957 = varonce956; +((struct instance_standard__NativeArray*)var794)->values[0]=var796; } else { -var958 = "(const struct type* type);"; -var959 = 26; -var960 = standard___standard__NativeString___to_s_with_length(var958, var959); -var957 = var960; -varonce956 = var957; -} -var961 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var961 = array_instance Array[Object] */ -var962 = 4; -var963 = NEW_standard__NativeArray(var962, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var963)->values[0] = (val*) var950; -((struct instance_standard__NativeArray*)var963)->values[1] = (val*) var952; -((struct instance_standard__NativeArray*)var963)->values[2] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var963)->values[3] = (val*) var957; -{ -((void (*)(val* self, val* p0, long p1))(var961->class->vft[COLOR_standard__array__Array__with_native]))(var961, var963, var962) /* with_native on */; -} +var794 = varonce793; +varonce793 = NULL; } +((struct instance_standard__NativeArray*)var794)->values[1]=var_c_name; { -var964 = ((val* (*)(val* self))(var961->class->vft[COLOR_standard__string__Object__to_s]))(var961) /* to_s on */; +var799 = ((val*(*)(val* self))(var794->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var794); /* native_to_s on */ } -{ -nit___nit__AbstractCompiler___provide_declaration(self, var949, var964); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ -} -if (varonce965) { -var966 = varonce965; +varonce793 = var794; +if (unlikely(varonce800==NULL)) { +var801 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce802!=NULL)) { +var803 = varonce802; } else { -var967 = "/* allocate "; -var968 = 12; -var969 = standard___standard__NativeString___to_s_with_length(var967, var968); -var966 = var969; -varonce965 = var966; +var804 = " NEW_"; +var805 = standard___standard__NativeString___to_s_with_length(var804, 5l); +var803 = var805; +varonce802 = var803; } -if (varonce970) { -var971 = varonce970; +((struct instance_standard__NativeArray*)var801)->values[1]=var803; +if (likely(varonce806!=NULL)) { +var807 = varonce806; } else { -var972 = " */"; -var973 = 3; -var974 = standard___standard__NativeString___to_s_with_length(var972, var973); -var971 = var974; -varonce970 = var971; -} -var975 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var975 = array_instance Array[Object] */ -var976 = 3; -var977 = NEW_standard__NativeArray(var976, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var977)->values[0] = (val*) var966; -((struct instance_standard__NativeArray*)var977)->values[1] = (val*) var_mtype; -((struct instance_standard__NativeArray*)var977)->values[2] = (val*) var971; -{ -((void (*)(val* self, val* p0, long p1))(var975->class->vft[COLOR_standard__array__Array__with_native]))(var975, var977, var976) /* with_native on */; +var808 = "(const struct type* type);"; +var809 = standard___standard__NativeString___to_s_with_length(var808, 26l); +var807 = var809; +varonce806 = var807; } +((struct instance_standard__NativeArray*)var801)->values[3]=var807; +} else { +var801 = varonce800; +varonce800 = NULL; } { -var978 = ((val* (*)(val* self))(var975->class->vft[COLOR_standard__string__Object__to_s]))(var975) /* to_s on */; +var810 = nit__abstract_compiler___MClassType___MType__ctype(var_mtype); } +((struct instance_standard__NativeArray*)var801)->values[0]=var810; +((struct instance_standard__NativeArray*)var801)->values[2]=var_c_name; { -nit___nit__AbstractCompilerVisitor___add_decl(var_v, var978); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +var811 = ((val*(*)(val* self))(var801->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var801); /* native_to_s on */ } +varonce800 = var801; { -var979 = nit__abstract_compiler___MClassType___MType__ctype(var_mtype); +nit___nit__AbstractCompiler___provide_declaration(self, var799, var811); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ } -if (varonce980) { -var981 = varonce980; +if (unlikely(varonce812==NULL)) { +var813 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce814!=NULL)) { +var815 = varonce814; } else { -var982 = " NEW_"; -var983 = 5; -var984 = standard___standard__NativeString___to_s_with_length(var982, var983); -var981 = var984; -varonce980 = var981; +var816 = "/* allocate "; +var817 = standard___standard__NativeString___to_s_with_length(var816, 12l); +var815 = var817; +varonce814 = var815; } -if (varonce985) { -var986 = varonce985; +((struct instance_standard__NativeArray*)var813)->values[0]=var815; +if (likely(varonce818!=NULL)) { +var819 = varonce818; } else { -var987 = "(const struct type* type) {"; -var988 = 27; -var989 = standard___standard__NativeString___to_s_with_length(var987, var988); -var986 = var989; -varonce985 = var986; -} -var990 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var990 = array_instance Array[Object] */ -var991 = 4; -var992 = NEW_standard__NativeArray(var991, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var992)->values[0] = (val*) var979; -((struct instance_standard__NativeArray*)var992)->values[1] = (val*) var981; -((struct instance_standard__NativeArray*)var992)->values[2] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var992)->values[3] = (val*) var986; -{ -((void (*)(val* self, val* p0, long p1))(var990->class->vft[COLOR_standard__array__Array__with_native]))(var990, var992, var991) /* with_native on */; -} +var820 = " */"; +var821 = standard___standard__NativeString___to_s_with_length(var820, 3l); +var819 = var821; +varonce818 = var819; } -{ -var993 = ((val* (*)(val* self))(var990->class->vft[COLOR_standard__string__Object__to_s]))(var990) /* to_s on */; -} -{ -nit___nit__AbstractCompilerVisitor___add_decl(var_v, var993); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ -} -if (var_is_dead){ -if (varonce994) { -var995 = varonce994; +((struct instance_standard__NativeArray*)var813)->values[2]=var819; } else { -var996 = " is DEAD"; -var997 = 8; -var998 = standard___standard__NativeString___to_s_with_length(var996, var997); -var995 = var998; -varonce994 = var995; -} -var999 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var999 = array_instance Array[Object] */ -var1000 = 2; -var1001 = NEW_standard__NativeArray(var1000, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var1001)->values[0] = (val*) var_mclass; -((struct instance_standard__NativeArray*)var1001)->values[1] = (val*) var995; -{ -((void (*)(val* self, val* p0, long p1))(var999->class->vft[COLOR_standard__array__Array__with_native]))(var999, var1001, var1000) /* with_native on */; -} -} -{ -var1002 = ((val* (*)(val* self))(var999->class->vft[COLOR_standard__string__Object__to_s]))(var999) /* to_s on */; +var813 = varonce812; +varonce812 = NULL; } { -nit___nit__AbstractCompilerVisitor___add_abort(var_v, var1002); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_abort on */ -} -} else { -if (varonce1003) { -var1004 = varonce1003; -} else { -var1005 = "self"; -var1006 = 4; -var1007 = standard___standard__NativeString___to_s_with_length(var1005, var1006); -var1004 = var1007; -varonce1003 = var1004; +var822 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_standard__string__Object__to_s]))(var_mtype); /* to_s on */ } +((struct instance_standard__NativeArray*)var813)->values[1]=var822; { -var1008 = nit___nit__AbstractCompilerVisitor___new_named_var(var_v, var_mtype, var1004); +var823 = ((val*(*)(val* self))(var813->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var813); /* native_to_s on */ } -var_res1009 = var1008; -var1010 = 1; +varonce812 = var813; { -{ /* Inline abstract_compiler#RuntimeVariable#is_exact= (var_res1009,var1010) on */ -var_res1009->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___is_exact].s = var1010; /* _is_exact on */ -RET_LABEL1011:(void)0; -} +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var823); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } -if (varonce1012) { -var1013 = varonce1012; +if (unlikely(varonce824==NULL)) { +var825 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce826!=NULL)) { +var827 = varonce826; } else { -var1014 = " = nit_alloc(sizeof(struct instance_"; -var1015 = 36; -var1016 = standard___standard__NativeString___to_s_with_length(var1014, var1015); -var1013 = var1016; -varonce1012 = var1013; -} -{ -var1017 = ((val* (*)(val* self))(var_pointer_type->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_pointer_type) /* c_name on */; +var828 = " NEW_"; +var829 = standard___standard__NativeString___to_s_with_length(var828, 5l); +var827 = var829; +varonce826 = var827; } -if (varonce1018) { -var1019 = varonce1018; +((struct instance_standard__NativeArray*)var825)->values[1]=var827; +if (likely(varonce830!=NULL)) { +var831 = varonce830; } else { -var1020 = "));"; -var1021 = 3; -var1022 = standard___standard__NativeString___to_s_with_length(var1020, var1021); -var1019 = var1022; -varonce1018 = var1019; -} -var1023 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var1023 = array_instance Array[Object] */ -var1024 = 4; -var1025 = NEW_standard__NativeArray(var1024, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var1025)->values[0] = (val*) var_res1009; -((struct instance_standard__NativeArray*)var1025)->values[1] = (val*) var1013; -((struct instance_standard__NativeArray*)var1025)->values[2] = (val*) var1017; -((struct instance_standard__NativeArray*)var1025)->values[3] = (val*) var1019; -{ -((void (*)(val* self, val* p0, long p1))(var1023->class->vft[COLOR_standard__array__Array__with_native]))(var1023, var1025, var1024) /* with_native on */; +var832 = "(const struct type* type) {"; +var833 = standard___standard__NativeString___to_s_with_length(var832, 27l); +var831 = var833; +varonce830 = var831; } -} -{ -var1026 = ((val* (*)(val* self))(var1023->class->vft[COLOR_standard__string__Object__to_s]))(var1023) /* to_s on */; -} -{ -nit___nit__AbstractCompilerVisitor___add(var_v, var1026); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ -} -if (varonce1027) { -var1028 = varonce1027; +((struct instance_standard__NativeArray*)var825)->values[3]=var831; } else { -var1029 = "->type = type;"; -var1030 = 14; -var1031 = standard___standard__NativeString___to_s_with_length(var1029, var1030); -var1028 = var1031; -varonce1027 = var1028; +var825 = varonce824; +varonce824 = NULL; } -var1032 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var1032 = array_instance Array[Object] */ -var1033 = 2; -var1034 = NEW_standard__NativeArray(var1033, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var1034)->values[0] = (val*) var_res1009; -((struct instance_standard__NativeArray*)var1034)->values[1] = (val*) var1028; { -((void (*)(val* self, val* p0, long p1))(var1032->class->vft[COLOR_standard__array__Array__with_native]))(var1032, var1034, var1033) /* with_native on */; -} +var834 = nit__abstract_compiler___MClassType___MType__ctype(var_mtype); } +((struct instance_standard__NativeArray*)var825)->values[0]=var834; +((struct instance_standard__NativeArray*)var825)->values[2]=var_c_name; { -var1035 = ((val* (*)(val* self))(var1032->class->vft[COLOR_standard__string__Object__to_s]))(var1032) /* to_s on */; +var835 = ((val*(*)(val* self))(var825->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var825); /* native_to_s on */ } +varonce824 = var825; { -nit___nit__AbstractCompilerVisitor___add(var_v, var1035); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var835); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } -if (varonce1036) { -var1037 = varonce1036; +if (var_is_dead){ +if (unlikely(varonce836==NULL)) { +var837 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce838!=NULL)) { +var839 = varonce838; } else { -var1038 = "type"; -var1039 = 4; -var1040 = standard___standard__NativeString___to_s_with_length(var1038, var1039); -var1037 = var1040; -varonce1036 = var1037; -} -{ -nit___nit__SeparateCompiler___hardening_live_type(self, var_v, var1037); /* Direct call separate_compiler#SeparateCompiler#hardening_live_type on */ +var840 = " is DEAD"; +var841 = standard___standard__NativeString___to_s_with_length(var840, 8l); +var839 = var841; +varonce838 = var839; } -if (varonce1041) { -var1042 = varonce1041; +((struct instance_standard__NativeArray*)var837)->values[1]=var839; } else { -var1043 = "class_"; -var1044 = 6; -var1045 = standard___standard__NativeString___to_s_with_length(var1043, var1044); -var1042 = var1045; -varonce1041 = var1042; +var837 = varonce836; +varonce836 = NULL; } -var1046 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var1046 = array_instance Array[Object] */ -var1047 = 2; -var1048 = NEW_standard__NativeArray(var1047, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var1048)->values[0] = (val*) var1042; -((struct instance_standard__NativeArray*)var1048)->values[1] = (val*) var_c_name; { -((void (*)(val* self, val* p0, long p1))(var1046->class->vft[COLOR_standard__array__Array__with_native]))(var1046, var1048, var1047) /* with_native on */; -} +var842 = ((val*(*)(val* self))(var_mclass->class->vft[COLOR_standard__string__Object__to_s]))(var_mclass); /* to_s on */ } +((struct instance_standard__NativeArray*)var837)->values[0]=var842; { -var1049 = ((val* (*)(val* self))(var1046->class->vft[COLOR_standard__string__Object__to_s]))(var1046) /* to_s on */; +var843 = ((val*(*)(val* self))(var837->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var837); /* native_to_s on */ } +varonce836 = var837; { -nit___nit__AbstractCompilerVisitor___require_declaration(var_v, var1049); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +nit___nit__AbstractCompilerVisitor___add_abort(var_v, var843); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_abort on */ } -if (varonce1050) { -var1051 = varonce1050; } else { -var1052 = "->class = &class_"; -var1053 = 17; -var1054 = standard___standard__NativeString___to_s_with_length(var1052, var1053); -var1051 = var1054; -varonce1050 = var1051; -} -if (varonce1055) { -var1056 = varonce1055; +if (likely(varonce844!=NULL)) { +var845 = varonce844; } else { -var1057 = ";"; -var1058 = 1; -var1059 = standard___standard__NativeString___to_s_with_length(var1057, var1058); -var1056 = var1059; -varonce1055 = var1056; +var846 = "self"; +var847 = standard___standard__NativeString___to_s_with_length(var846, 4l); +var845 = var847; +varonce844 = var845; } -var1060 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var1060 = array_instance Array[Object] */ -var1061 = 4; -var1062 = NEW_standard__NativeArray(var1061, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var1062)->values[0] = (val*) var_res1009; -((struct instance_standard__NativeArray*)var1062)->values[1] = (val*) var1051; -((struct instance_standard__NativeArray*)var1062)->values[2] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var1062)->values[3] = (val*) var1056; { -((void (*)(val* self, val* p0, long p1))(var1060->class->vft[COLOR_standard__array__Array__with_native]))(var1060, var1062, var1061) /* with_native on */; -} +var848 = nit___nit__AbstractCompilerVisitor___new_named_var(var_v, var_mtype, var845); } +var_res849 = var848; { -var1063 = ((val* (*)(val* self))(var1060->class->vft[COLOR_standard__string__Object__to_s]))(var1060) /* to_s on */; +{ /* Inline abstract_compiler#RuntimeVariable#is_exact= (var_res849,1) on */ +var_res849->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___is_exact].s = 1; /* _is_exact on */ +RET_LABEL850:(void)0; } -{ -nit___nit__AbstractCompilerVisitor___add(var_v, var1063); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce1064) { -var1065 = varonce1064; +if (unlikely(varonce851==NULL)) { +var852 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce853!=NULL)) { +var854 = varonce853; } else { -var1066 = "((struct instance_"; -var1067 = 18; -var1068 = standard___standard__NativeString___to_s_with_length(var1066, var1067); -var1065 = var1068; -varonce1064 = var1065; -} -{ -var1069 = ((val* (*)(val* self))(var_pointer_type->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_pointer_type) /* c_name on */; +var855 = " = nit_alloc(sizeof(struct instance_"; +var856 = standard___standard__NativeString___to_s_with_length(var855, 36l); +var854 = var856; +varonce853 = var854; } -if (varonce1070) { -var1071 = varonce1070; +((struct instance_standard__NativeArray*)var852)->values[1]=var854; +if (likely(varonce857!=NULL)) { +var858 = varonce857; } else { -var1072 = "*)"; -var1073 = 2; -var1074 = standard___standard__NativeString___to_s_with_length(var1072, var1073); -var1071 = var1074; -varonce1070 = var1071; +var859 = "));"; +var860 = standard___standard__NativeString___to_s_with_length(var859, 3l); +var858 = var860; +varonce857 = var858; } -if (varonce1075) { -var1076 = varonce1075; +((struct instance_standard__NativeArray*)var852)->values[3]=var858; } else { -var1077 = ")->value = NULL;"; -var1078 = 16; -var1079 = standard___standard__NativeString___to_s_with_length(var1077, var1078); -var1076 = var1079; -varonce1075 = var1076; +var852 = varonce851; +varonce851 = NULL; } -var1080 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var1080 = array_instance Array[Object] */ -var1081 = 5; -var1082 = NEW_standard__NativeArray(var1081, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var1082)->values[0] = (val*) var1065; -((struct instance_standard__NativeArray*)var1082)->values[1] = (val*) var1069; -((struct instance_standard__NativeArray*)var1082)->values[2] = (val*) var1071; -((struct instance_standard__NativeArray*)var1082)->values[3] = (val*) var_res1009; -((struct instance_standard__NativeArray*)var1082)->values[4] = (val*) var1076; { -((void (*)(val* self, val* p0, long p1))(var1080->class->vft[COLOR_standard__array__Array__with_native]))(var1080, var1082, var1081) /* with_native on */; +var861 = ((val*(*)(val* self))(var_res849->class->vft[COLOR_standard__string__Object__to_s]))(var_res849); /* to_s on */ } +((struct instance_standard__NativeArray*)var852)->values[0]=var861; +{ +var862 = ((val*(*)(val* self))(var_pointer_type->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_pointer_type); /* c_name on */ } +((struct instance_standard__NativeArray*)var852)->values[2]=var862; { -var1083 = ((val* (*)(val* self))(var1080->class->vft[COLOR_standard__string__Object__to_s]))(var1080) /* to_s on */; +var863 = ((val*(*)(val* self))(var852->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var852); /* native_to_s on */ } +varonce851 = var852; { -nit___nit__AbstractCompilerVisitor___add(var_v, var1083); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var863); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce1084) { -var1085 = varonce1084; +if (unlikely(varonce864==NULL)) { +var865 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce866!=NULL)) { +var867 = varonce866; } else { -var1086 = "return "; -var1087 = 7; -var1088 = standard___standard__NativeString___to_s_with_length(var1086, var1087); -var1085 = var1088; -varonce1084 = var1085; +var868 = "->type = type;"; +var869 = standard___standard__NativeString___to_s_with_length(var868, 14l); +var867 = var869; +varonce866 = var867; } -if (varonce1089) { -var1090 = varonce1089; +((struct instance_standard__NativeArray*)var865)->values[1]=var867; } else { -var1091 = ";"; -var1092 = 1; -var1093 = standard___standard__NativeString___to_s_with_length(var1091, var1092); -var1090 = var1093; -varonce1089 = var1090; +var865 = varonce864; +varonce864 = NULL; } -var1094 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var1094 = array_instance Array[Object] */ -var1095 = 3; -var1096 = NEW_standard__NativeArray(var1095, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var1096)->values[0] = (val*) var1085; -((struct instance_standard__NativeArray*)var1096)->values[1] = (val*) var_res1009; -((struct instance_standard__NativeArray*)var1096)->values[2] = (val*) var1090; { -((void (*)(val* self, val* p0, long p1))(var1094->class->vft[COLOR_standard__array__Array__with_native]))(var1094, var1096, var1095) /* with_native on */; -} +var870 = ((val*(*)(val* self))(var_res849->class->vft[COLOR_standard__string__Object__to_s]))(var_res849); /* to_s on */ } +((struct instance_standard__NativeArray*)var865)->values[0]=var870; { -var1097 = ((val* (*)(val* self))(var1094->class->vft[COLOR_standard__string__Object__to_s]))(var1094) /* to_s on */; +var871 = ((val*(*)(val* self))(var865->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var865); /* native_to_s on */ } +varonce864 = var865; { -nit___nit__AbstractCompilerVisitor___add(var_v, var1097); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var871); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -} -if (varonce1098) { -var1099 = varonce1098; +if (likely(varonce872!=NULL)) { +var873 = varonce872; } else { -var1100 = "}"; -var1101 = 1; -var1102 = standard___standard__NativeString___to_s_with_length(var1100, var1101); -var1099 = var1102; -varonce1098 = var1099; +var874 = "type"; +var875 = standard___standard__NativeString___to_s_with_length(var874, 4l); +var873 = var875; +varonce872 = var873; } { -nit___nit__AbstractCompilerVisitor___add(var_v, var1099); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__SeparateCompiler___hardening_live_type(self, var_v, var873); /* Direct call separate_compiler#SeparateCompiler#hardening_live_type on */ } -goto RET_LABEL; +if (unlikely(varonce876==NULL)) { +var877 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce878!=NULL)) { +var879 = varonce878; } else { +var880 = "class_"; +var881 = standard___standard__NativeString___to_s_with_length(var880, 6l); +var879 = var881; +varonce878 = var879; } -} -} -if (varonce1103) { -var1104 = varonce1103; +((struct instance_standard__NativeArray*)var877)->values[0]=var879; } else { -var1105 = "NEW_"; -var1106 = 4; -var1107 = standard___standard__NativeString___to_s_with_length(var1105, var1106); -var1104 = var1107; -varonce1103 = var1104; +var877 = varonce876; +varonce876 = NULL; } -var1108 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var1108 = array_instance Array[Object] */ -var1109 = 2; -var1110 = NEW_standard__NativeArray(var1109, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var1110)->values[0] = (val*) var1104; -((struct instance_standard__NativeArray*)var1110)->values[1] = (val*) var_c_name; +((struct instance_standard__NativeArray*)var877)->values[1]=var_c_name; { -((void (*)(val* self, val* p0, long p1))(var1108->class->vft[COLOR_standard__array__Array__with_native]))(var1108, var1110, var1109) /* with_native on */; -} +var882 = ((val*(*)(val* self))(var877->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var877); /* native_to_s on */ } +varonce876 = var877; { -var1111 = ((val* (*)(val* self))(var1108->class->vft[COLOR_standard__string__Object__to_s]))(var1108) /* to_s on */; +nit___nit__AbstractCompilerVisitor___require_declaration(var_v, var882); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ } -{ -var1112 = nit__abstract_compiler___MClassType___MType__ctype(var_mtype); +if (unlikely(varonce883==NULL)) { +var884 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce885!=NULL)) { +var886 = varonce885; +} else { +var887 = "->class = &class_"; +var888 = standard___standard__NativeString___to_s_with_length(var887, 17l); +var886 = var888; +varonce885 = var886; } -if (varonce1113) { -var1114 = varonce1113; +((struct instance_standard__NativeArray*)var884)->values[1]=var886; +if (likely(varonce889!=NULL)) { +var890 = varonce889; } else { -var1115 = " NEW_"; -var1116 = 5; -var1117 = standard___standard__NativeString___to_s_with_length(var1115, var1116); -var1114 = var1117; -varonce1113 = var1114; +var891 = ";"; +var892 = standard___standard__NativeString___to_s_with_length(var891, 1l); +var890 = var892; +varonce889 = var890; } -if (varonce1118) { -var1119 = varonce1118; +((struct instance_standard__NativeArray*)var884)->values[3]=var890; } else { -var1120 = "(const struct type* type);"; -var1121 = 26; -var1122 = standard___standard__NativeString___to_s_with_length(var1120, var1121); -var1119 = var1122; -varonce1118 = var1119; +var884 = varonce883; +varonce883 = NULL; } -var1123 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var1123 = array_instance Array[Object] */ -var1124 = 4; -var1125 = NEW_standard__NativeArray(var1124, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var1125)->values[0] = (val*) var1112; -((struct instance_standard__NativeArray*)var1125)->values[1] = (val*) var1114; -((struct instance_standard__NativeArray*)var1125)->values[2] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var1125)->values[3] = (val*) var1119; { -((void (*)(val* self, val* p0, long p1))(var1123->class->vft[COLOR_standard__array__Array__with_native]))(var1123, var1125, var1124) /* with_native on */; -} +var893 = ((val*(*)(val* self))(var_res849->class->vft[COLOR_standard__string__Object__to_s]))(var_res849); /* to_s on */ } +((struct instance_standard__NativeArray*)var884)->values[0]=var893; +((struct instance_standard__NativeArray*)var884)->values[2]=var_c_name; { -var1126 = ((val* (*)(val* self))(var1123->class->vft[COLOR_standard__string__Object__to_s]))(var1123) /* to_s on */; +var894 = ((val*(*)(val* self))(var884->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var884); /* native_to_s on */ } +varonce883 = var884; { -nit___nit__AbstractCompiler___provide_declaration(self, var1111, var1126); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var894); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce1127) { -var1128 = varonce1127; +if (unlikely(varonce895==NULL)) { +var896 = NEW_standard__NativeArray(5l, &type_standard__NativeArray__standard__String); +if (likely(varonce897!=NULL)) { +var898 = varonce897; } else { -var1129 = "/* allocate "; -var1130 = 12; -var1131 = standard___standard__NativeString___to_s_with_length(var1129, var1130); -var1128 = var1131; -varonce1127 = var1128; +var899 = "((struct instance_"; +var900 = standard___standard__NativeString___to_s_with_length(var899, 18l); +var898 = var900; +varonce897 = var898; } -if (varonce1132) { -var1133 = varonce1132; +((struct instance_standard__NativeArray*)var896)->values[0]=var898; +if (likely(varonce901!=NULL)) { +var902 = varonce901; } else { -var1134 = " */"; -var1135 = 3; -var1136 = standard___standard__NativeString___to_s_with_length(var1134, var1135); -var1133 = var1136; -varonce1132 = var1133; +var903 = "*)"; +var904 = standard___standard__NativeString___to_s_with_length(var903, 2l); +var902 = var904; +varonce901 = var902; } -var1137 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var1137 = array_instance Array[Object] */ -var1138 = 3; -var1139 = NEW_standard__NativeArray(var1138, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var1139)->values[0] = (val*) var1128; -((struct instance_standard__NativeArray*)var1139)->values[1] = (val*) var_mtype; -((struct instance_standard__NativeArray*)var1139)->values[2] = (val*) var1133; -{ -((void (*)(val* self, val* p0, long p1))(var1137->class->vft[COLOR_standard__array__Array__with_native]))(var1137, var1139, var1138) /* with_native on */; +((struct instance_standard__NativeArray*)var896)->values[2]=var902; +if (likely(varonce905!=NULL)) { +var906 = varonce905; +} else { +var907 = ")->value = NULL;"; +var908 = standard___standard__NativeString___to_s_with_length(var907, 16l); +var906 = var908; +varonce905 = var906; } +((struct instance_standard__NativeArray*)var896)->values[4]=var906; +} else { +var896 = varonce895; +varonce895 = NULL; } { -var1140 = ((val* (*)(val* self))(var1137->class->vft[COLOR_standard__string__Object__to_s]))(var1137) /* to_s on */; +var909 = ((val*(*)(val* self))(var_pointer_type->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_pointer_type); /* c_name on */ } +((struct instance_standard__NativeArray*)var896)->values[1]=var909; { -nit___nit__AbstractCompilerVisitor___add_decl(var_v, var1140); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +var910 = ((val*(*)(val* self))(var_res849->class->vft[COLOR_standard__string__Object__to_s]))(var_res849); /* to_s on */ } +((struct instance_standard__NativeArray*)var896)->values[3]=var910; { -var1141 = nit__abstract_compiler___MClassType___MType__ctype(var_mtype); +var911 = ((val*(*)(val* self))(var896->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var896); /* native_to_s on */ } -if (varonce1142) { -var1143 = varonce1142; -} else { -var1144 = " NEW_"; -var1145 = 5; -var1146 = standard___standard__NativeString___to_s_with_length(var1144, var1145); -var1143 = var1146; -varonce1142 = var1143; +varonce895 = var896; +{ +nit___nit__AbstractCompilerVisitor___add(var_v, var911); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce1147) { -var1148 = varonce1147; +if (unlikely(varonce912==NULL)) { +var913 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce914!=NULL)) { +var915 = varonce914; } else { -var1149 = "(const struct type* type) {"; -var1150 = 27; -var1151 = standard___standard__NativeString___to_s_with_length(var1149, var1150); -var1148 = var1151; -varonce1147 = var1148; +var916 = "return "; +var917 = standard___standard__NativeString___to_s_with_length(var916, 7l); +var915 = var917; +varonce914 = var915; } -var1152 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var1152 = array_instance Array[Object] */ -var1153 = 4; -var1154 = NEW_standard__NativeArray(var1153, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var1154)->values[0] = (val*) var1141; -((struct instance_standard__NativeArray*)var1154)->values[1] = (val*) var1143; -((struct instance_standard__NativeArray*)var1154)->values[2] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var1154)->values[3] = (val*) var1148; -{ -((void (*)(val* self, val* p0, long p1))(var1152->class->vft[COLOR_standard__array__Array__with_native]))(var1152, var1154, var1153) /* with_native on */; +((struct instance_standard__NativeArray*)var913)->values[0]=var915; +if (likely(varonce918!=NULL)) { +var919 = varonce918; +} else { +var920 = ";"; +var921 = standard___standard__NativeString___to_s_with_length(var920, 1l); +var919 = var921; +varonce918 = var919; } +((struct instance_standard__NativeArray*)var913)->values[2]=var919; +} else { +var913 = varonce912; +varonce912 = NULL; } { -var1155 = ((val* (*)(val* self))(var1152->class->vft[COLOR_standard__string__Object__to_s]))(var1152) /* to_s on */; +var922 = ((val*(*)(val* self))(var_res849->class->vft[COLOR_standard__string__Object__to_s]))(var_res849); /* to_s on */ } +((struct instance_standard__NativeArray*)var913)->values[1]=var922; { -nit___nit__AbstractCompilerVisitor___add_decl(var_v, var1155); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +var923 = ((val*(*)(val* self))(var913->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var913); /* native_to_s on */ } -if (var_is_dead){ -if (varonce1156) { -var1157 = varonce1156; -} else { -var1158 = " is DEAD"; -var1159 = 8; -var1160 = standard___standard__NativeString___to_s_with_length(var1158, var1159); -var1157 = var1160; -varonce1156 = var1157; -} -var1161 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var1161 = array_instance Array[Object] */ -var1162 = 2; -var1163 = NEW_standard__NativeArray(var1162, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var1163)->values[0] = (val*) var_mclass; -((struct instance_standard__NativeArray*)var1163)->values[1] = (val*) var1157; +varonce912 = var913; { -((void (*)(val* self, val* p0, long p1))(var1161->class->vft[COLOR_standard__array__Array__with_native]))(var1161, var1163, var1162) /* with_native on */; +nit___nit__AbstractCompilerVisitor___add(var_v, var923); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } } -{ -var1164 = ((val* (*)(val* self))(var1161->class->vft[COLOR_standard__string__Object__to_s]))(var1161) /* to_s on */; +if (likely(varonce924!=NULL)) { +var925 = varonce924; +} else { +var926 = "}"; +var927 = standard___standard__NativeString___to_s_with_length(var926, 1l); +var925 = var927; +varonce924 = var925; } { -nit___nit__AbstractCompilerVisitor___add_abort(var_v, var1164); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_abort on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var925); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } +goto RET_LABEL; } else { -if (varonce1165) { -var1166 = varonce1165; -} else { -var1167 = "self"; -var1168 = 4; -var1169 = standard___standard__NativeString___to_s_with_length(var1167, var1168); -var1166 = var1169; -varonce1165 = var1166; } -{ -var1170 = nit___nit__AbstractCompilerVisitor___new_named_var(var_v, var_mtype, var1166); } -var_res1171 = var1170; -var1172 = 1; -{ -{ /* Inline abstract_compiler#RuntimeVariable#is_exact= (var_res1171,var1172) on */ -var_res1171->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___is_exact].s = var1172; /* _is_exact on */ -RET_LABEL1173:(void)0; } +if (unlikely(varonce928==NULL)) { +var929 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce930!=NULL)) { +var931 = varonce930; +} else { +var932 = "NEW_"; +var933 = standard___standard__NativeString___to_s_with_length(var932, 4l); +var931 = var933; +varonce930 = var931; } -if (varonce1174) { -var1175 = varonce1174; +((struct instance_standard__NativeArray*)var929)->values[0]=var931; } else { -var1176 = " = nit_alloc(sizeof(struct instance) + "; -var1177 = 39; -var1178 = standard___standard__NativeString___to_s_with_length(var1176, var1177); -var1175 = var1178; -varonce1174 = var1175; +var929 = varonce928; +varonce928 = NULL; } +((struct instance_standard__NativeArray*)var929)->values[1]=var_c_name; { -{ /* Inline array#AbstractArrayRead#length (var_attrs) on */ -var1181 = var_attrs->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ -var1179 = var1181; -RET_LABEL1180:(void)0; +var934 = ((val*(*)(val* self))(var929->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var929); /* native_to_s on */ } +varonce928 = var929; +if (unlikely(varonce935==NULL)) { +var936 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce937!=NULL)) { +var938 = varonce937; +} else { +var939 = " NEW_"; +var940 = standard___standard__NativeString___to_s_with_length(var939, 5l); +var938 = var940; +varonce937 = var938; +} +((struct instance_standard__NativeArray*)var936)->values[1]=var938; +if (likely(varonce941!=NULL)) { +var942 = varonce941; +} else { +var943 = "(const struct type* type);"; +var944 = standard___standard__NativeString___to_s_with_length(var943, 26l); +var942 = var944; +varonce941 = var942; } -if (varonce1182) { -var1183 = varonce1182; +((struct instance_standard__NativeArray*)var936)->values[3]=var942; } else { -var1184 = "*sizeof(nitattribute_t));"; -var1185 = 25; -var1186 = standard___standard__NativeString___to_s_with_length(var1184, var1185); -var1183 = var1186; -varonce1182 = var1183; +var936 = varonce935; +varonce935 = NULL; } -var1187 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var1187 = array_instance Array[Object] */ -var1188 = 4; -var1189 = NEW_standard__NativeArray(var1188, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var1189)->values[0] = (val*) var_res1171; -((struct instance_standard__NativeArray*)var1189)->values[1] = (val*) var1175; -var1190 = BOX_standard__Int(var1179); /* autobox from Int to Object */ -((struct instance_standard__NativeArray*)var1189)->values[2] = (val*) var1190; -((struct instance_standard__NativeArray*)var1189)->values[3] = (val*) var1183; { -((void (*)(val* self, val* p0, long p1))(var1187->class->vft[COLOR_standard__array__Array__with_native]))(var1187, var1189, var1188) /* with_native on */; -} +var945 = nit__abstract_compiler___MClassType___MType__ctype(var_mtype); } +((struct instance_standard__NativeArray*)var936)->values[0]=var945; +((struct instance_standard__NativeArray*)var936)->values[2]=var_c_name; { -var1191 = ((val* (*)(val* self))(var1187->class->vft[COLOR_standard__string__Object__to_s]))(var1187) /* to_s on */; +var946 = ((val*(*)(val* self))(var936->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var936); /* native_to_s on */ } +varonce935 = var936; { -nit___nit__AbstractCompilerVisitor___add(var_v, var1191); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompiler___provide_declaration(self, var934, var946); /* Direct call abstract_compiler#AbstractCompiler#provide_declaration on */ } -if (varonce1192) { -var1193 = varonce1192; +if (unlikely(varonce947==NULL)) { +var948 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce949!=NULL)) { +var950 = varonce949; } else { -var1194 = "->type = type;"; -var1195 = 14; -var1196 = standard___standard__NativeString___to_s_with_length(var1194, var1195); -var1193 = var1196; -varonce1192 = var1193; +var951 = "/* allocate "; +var952 = standard___standard__NativeString___to_s_with_length(var951, 12l); +var950 = var952; +varonce949 = var950; } -var1197 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var1197 = array_instance Array[Object] */ -var1198 = 2; -var1199 = NEW_standard__NativeArray(var1198, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var1199)->values[0] = (val*) var_res1171; -((struct instance_standard__NativeArray*)var1199)->values[1] = (val*) var1193; -{ -((void (*)(val* self, val* p0, long p1))(var1197->class->vft[COLOR_standard__array__Array__with_native]))(var1197, var1199, var1198) /* with_native on */; +((struct instance_standard__NativeArray*)var948)->values[0]=var950; +if (likely(varonce953!=NULL)) { +var954 = varonce953; +} else { +var955 = " */"; +var956 = standard___standard__NativeString___to_s_with_length(var955, 3l); +var954 = var956; +varonce953 = var954; +} +((struct instance_standard__NativeArray*)var948)->values[2]=var954; +} else { +var948 = varonce947; +varonce947 = NULL; } +{ +var957 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_standard__string__Object__to_s]))(var_mtype); /* to_s on */ } +((struct instance_standard__NativeArray*)var948)->values[1]=var957; { -var1200 = ((val* (*)(val* self))(var1197->class->vft[COLOR_standard__string__Object__to_s]))(var1197) /* to_s on */; +var958 = ((val*(*)(val* self))(var948->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var948); /* native_to_s on */ } +varonce947 = var948; { -nit___nit__AbstractCompilerVisitor___add(var_v, var1200); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var958); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } -if (varonce1201) { -var1202 = varonce1201; +if (unlikely(varonce959==NULL)) { +var960 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce961!=NULL)) { +var962 = varonce961; } else { -var1203 = "type"; -var1204 = 4; -var1205 = standard___standard__NativeString___to_s_with_length(var1203, var1204); -var1202 = var1205; -varonce1201 = var1202; +var963 = " NEW_"; +var964 = standard___standard__NativeString___to_s_with_length(var963, 5l); +var962 = var964; +varonce961 = var962; } -{ -nit___nit__SeparateCompiler___hardening_live_type(self, var_v, var1202); /* Direct call separate_compiler#SeparateCompiler#hardening_live_type on */ +((struct instance_standard__NativeArray*)var960)->values[1]=var962; +if (likely(varonce965!=NULL)) { +var966 = varonce965; +} else { +var967 = "(const struct type* type) {"; +var968 = standard___standard__NativeString___to_s_with_length(var967, 27l); +var966 = var968; +varonce965 = var966; } -if (varonce1206) { -var1207 = varonce1206; +((struct instance_standard__NativeArray*)var960)->values[3]=var966; } else { -var1208 = "class_"; -var1209 = 6; -var1210 = standard___standard__NativeString___to_s_with_length(var1208, var1209); -var1207 = var1210; -varonce1206 = var1207; +var960 = varonce959; +varonce959 = NULL; } -var1211 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var1211 = array_instance Array[Object] */ -var1212 = 2; -var1213 = NEW_standard__NativeArray(var1212, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var1213)->values[0] = (val*) var1207; -((struct instance_standard__NativeArray*)var1213)->values[1] = (val*) var_c_name; { -((void (*)(val* self, val* p0, long p1))(var1211->class->vft[COLOR_standard__array__Array__with_native]))(var1211, var1213, var1212) /* with_native on */; -} +var969 = nit__abstract_compiler___MClassType___MType__ctype(var_mtype); } +((struct instance_standard__NativeArray*)var960)->values[0]=var969; +((struct instance_standard__NativeArray*)var960)->values[2]=var_c_name; { -var1214 = ((val* (*)(val* self))(var1211->class->vft[COLOR_standard__string__Object__to_s]))(var1211) /* to_s on */; +var970 = ((val*(*)(val* self))(var960->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var960); /* native_to_s on */ } +varonce959 = var960; { -nit___nit__AbstractCompilerVisitor___require_declaration(var_v, var1214); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var970); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } -if (varonce1215) { -var1216 = varonce1215; +if (var_is_dead){ +if (unlikely(varonce971==NULL)) { +var972 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce973!=NULL)) { +var974 = varonce973; } else { -var1217 = "->class = &class_"; -var1218 = 17; -var1219 = standard___standard__NativeString___to_s_with_length(var1217, var1218); -var1216 = var1219; -varonce1215 = var1216; +var975 = " is DEAD"; +var976 = standard___standard__NativeString___to_s_with_length(var975, 8l); +var974 = var976; +varonce973 = var974; } -if (varonce1220) { -var1221 = varonce1220; +((struct instance_standard__NativeArray*)var972)->values[1]=var974; } else { -var1222 = ";"; -var1223 = 1; -var1224 = standard___standard__NativeString___to_s_with_length(var1222, var1223); -var1221 = var1224; -varonce1220 = var1221; +var972 = varonce971; +varonce971 = NULL; } -var1225 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var1225 = array_instance Array[Object] */ -var1226 = 4; -var1227 = NEW_standard__NativeArray(var1226, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var1227)->values[0] = (val*) var_res1171; -((struct instance_standard__NativeArray*)var1227)->values[1] = (val*) var1216; -((struct instance_standard__NativeArray*)var1227)->values[2] = (val*) var_c_name; -((struct instance_standard__NativeArray*)var1227)->values[3] = (val*) var1221; { -((void (*)(val* self, val* p0, long p1))(var1225->class->vft[COLOR_standard__array__Array__with_native]))(var1225, var1227, var1226) /* with_native on */; -} -} -{ -var1228 = ((val* (*)(val* self))(var1225->class->vft[COLOR_standard__string__Object__to_s]))(var1225) /* to_s on */; -} -{ -nit___nit__AbstractCompilerVisitor___add(var_v, var1228); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +var977 = ((val*(*)(val* self))(var_mclass->class->vft[COLOR_standard__string__Object__to_s]))(var_mclass); /* to_s on */ } +((struct instance_standard__NativeArray*)var972)->values[0]=var977; { -nit___nit__AbstractCompiler___generate_init_attr(self, var_v, var_res1171, var_mtype); /* Direct call abstract_compiler#AbstractCompiler#generate_init_attr on */ +var978 = ((val*(*)(val* self))(var972->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var972); /* native_to_s on */ } +varonce971 = var972; { -nit___nit__AbstractCompilerVisitor___set_finalizer(var_v, var_res1171); /* Direct call abstract_compiler#AbstractCompilerVisitor#set_finalizer on */ +nit___nit__AbstractCompilerVisitor___add_abort(var_v, var978); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_abort on */ } -if (varonce1229) { -var1230 = varonce1229; } else { -var1231 = "return "; -var1232 = 7; -var1233 = standard___standard__NativeString___to_s_with_length(var1231, var1232); -var1230 = var1233; -varonce1229 = var1230; -} -if (varonce1234) { -var1235 = varonce1234; +if (likely(varonce979!=NULL)) { +var980 = varonce979; } else { -var1236 = ";"; -var1237 = 1; -var1238 = standard___standard__NativeString___to_s_with_length(var1236, var1237); -var1235 = var1238; -varonce1234 = var1235; +var981 = "self"; +var982 = standard___standard__NativeString___to_s_with_length(var981, 4l); +var980 = var982; +varonce979 = var980; } -var1239 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var1239 = array_instance Array[Object] */ -var1240 = 3; -var1241 = NEW_standard__NativeArray(var1240, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var1241)->values[0] = (val*) var1230; -((struct instance_standard__NativeArray*)var1241)->values[1] = (val*) var_res1171; -((struct instance_standard__NativeArray*)var1241)->values[2] = (val*) var1235; { -((void (*)(val* self, val* p0, long p1))(var1239->class->vft[COLOR_standard__array__Array__with_native]))(var1239, var1241, var1240) /* with_native on */; -} +var983 = nit___nit__AbstractCompilerVisitor___new_named_var(var_v, var_mtype, var980); } +var_res984 = var983; { -var1242 = ((val* (*)(val* self))(var1239->class->vft[COLOR_standard__string__Object__to_s]))(var1239) /* to_s on */; +{ /* Inline abstract_compiler#RuntimeVariable#is_exact= (var_res984,1) on */ +var_res984->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___is_exact].s = 1; /* _is_exact on */ +RET_LABEL985:(void)0; +} } { -nit___nit__AbstractCompilerVisitor___add(var_v, var1242); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +{ /* Inline separate_compiler#SeparateCompiler#attr_tables (self) on */ +var988 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___attr_tables].val; /* _attr_tables on */ +if (unlikely(var988 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _attr_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 1054); +fatal_exit(1); } +var986 = var988; +RET_LABEL987:(void)0; } -if (varonce1243) { -var1244 = varonce1243; -} else { -var1245 = "}"; -var1246 = 1; -var1247 = standard___standard__NativeString___to_s_with_length(var1245, var1246); -var1244 = var1247; -varonce1243 = var1244; } { -nit___nit__AbstractCompilerVisitor___add(var_v, var1244); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ -} -RET_LABEL:; +var989 = ((val*(*)(val* self, val* p0))((((long)var986&3)?class_info[((long)var986&3)]:var986->class)->vft[COLOR_standard__abstract_collection__MapRead__get_or_null]))(var986, var_mclass); /* get_or_null on */ } -/* method separate_compiler#SeparateCompiler#hardening_live_type for (self: SeparateCompiler, SeparateCompilerVisitor, String) */ -void nit___nit__SeparateCompiler___hardening_live_type(val* self, val* p0, val* p1) { -short int var /* : Bool */; -int cltype; -int idtype; -const struct type* type_struct; -const char* var_class_name; -val* var_v /* var v: SeparateCompilerVisitor */; -val* var_t /* var t: String */; -val* var1 /* : AbstractCompiler */; -val* var3 /* : AbstractCompiler */; -val* var4 /* : ModelBuilder */; -val* var6 /* : ModelBuilder */; -val* var7 /* : ToolContext */; -val* var9 /* : ToolContext */; -val* var10 /* : OptionBool */; -val* var12 /* : OptionBool */; -val* var13 /* : nullable Object */; -val* var15 /* : nullable Object */; -short int var16 /* : Bool */; -short int var17 /* : Bool */; -static val* varonce; -val* var18 /* : String */; -char* var19 /* : NativeString */; -long var20 /* : Int */; -val* var21 /* : FlatString */; -static val* varonce22; -val* var23 /* : String */; -char* var24 /* : NativeString */; -long var25 /* : Int */; -val* var26 /* : FlatString */; -val* var27 /* : Array[Object] */; -long var28 /* : Int */; -val* var29 /* : NativeArray[Object] */; -val* var30 /* : String */; -static val* varonce31; -val* var32 /* : String */; -char* var33 /* : NativeString */; -long var34 /* : Int */; -val* var35 /* : FlatString */; -static val* varonce36; -val* var37 /* : String */; -char* var38 /* : NativeString */; -long var39 /* : Int */; -val* var40 /* : FlatString */; -static val* varonce41; -val* var42 /* : String */; -char* var43 /* : NativeString */; -long var44 /* : Int */; -val* var45 /* : FlatString */; -static val* varonce46; -val* var47 /* : String */; -char* var48 /* : NativeString */; -long var49 /* : Int */; -val* var50 /* : FlatString */; -val* var51 /* : Array[Object] */; -long var52 /* : Int */; -val* var53 /* : NativeArray[Object] */; -val* var54 /* : String */; -static val* varonce55; -val* var56 /* : String */; -char* var57 /* : NativeString */; -long var58 /* : Int */; -val* var59 /* : FlatString */; -static val* varonce60; -val* var61 /* : String */; -char* var62 /* : NativeString */; -long var63 /* : Int */; -val* var64 /* : FlatString */; -val* var65 /* : Array[Object] */; -long var66 /* : Int */; -val* var67 /* : NativeArray[Object] */; -val* var68 /* : String */; -static val* varonce69; -val* var70 /* : String */; -char* var71 /* : NativeString */; -long var72 /* : Int */; -val* var73 /* : FlatString */; -static val* varonce74; -val* var75 /* : String */; -char* var76 /* : NativeString */; -long var77 /* : Int */; -val* var78 /* : FlatString */; -/* Covariant cast for argument 0 (v) isa VISITOR */ -/* isa VISITOR */ -type_struct = self->type->resolution_table->types[COLOR_nit__abstract_compiler__AbstractCompiler__VISITOR]; -cltype = type_struct->color; -idtype = type_struct->id; -if(cltype >= p0->type->table_size) { -var = 0; +var_attrs = var989; +if (var_attrs == NULL) { +var990 = 1; /* is null */ } else { -var = p0->type->type_table[cltype] == idtype; +var990 = 0; /* arg is null but recv is not */ } -if (unlikely(!var)) { -var_class_name = p0 == NULL ? "null" : p0->type->name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "VISITOR", var_class_name); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 837); -show_backtrace(1); -} -var_v = p0; -var_t = p1; -{ -{ /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (var_v) on */ -var3 = var_v->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ -if (unlikely(var3 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1059); -show_backtrace(1); +if (0) { +var991 = standard___standard__Array___standard__kernel__Object___61d_61d(var_attrs, ((val*)NULL)); +var990 = var991; } -var1 = var3; -RET_LABEL2:(void)0; +if (var990){ +if (unlikely(varonce992==NULL)) { +var993 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce994!=NULL)) { +var995 = varonce994; +} else { +var996 = " = nit_alloc(sizeof(struct instance));"; +var997 = standard___standard__NativeString___to_s_with_length(var996, 38l); +var995 = var997; +varonce994 = var995; } +((struct instance_standard__NativeArray*)var993)->values[1]=var995; +} else { +var993 = varonce992; +varonce992 = NULL; } { -{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (var1) on */ -var6 = var1->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ -if (unlikely(var6 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); -show_backtrace(1); -} -var4 = var6; -RET_LABEL5:(void)0; +var998 = ((val*(*)(val* self))(var_res984->class->vft[COLOR_standard__string__Object__to_s]))(var_res984); /* to_s on */ } +((struct instance_standard__NativeArray*)var993)->values[0]=var998; +{ +var999 = ((val*(*)(val* self))(var993->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var993); /* native_to_s on */ } +varonce992 = var993; { -{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var4) on */ -var9 = var4->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ -if (unlikely(var9 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47); -show_backtrace(1); +nit___nit__AbstractCompilerVisitor___add(var_v, var999); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -var7 = var9; -RET_LABEL8:(void)0; +} else { +if (unlikely(varonce1000==NULL)) { +var1001 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce1002!=NULL)) { +var1003 = varonce1002; +} else { +var1004 = " = nit_alloc(sizeof(struct instance) + "; +var1005 = standard___standard__NativeString___to_s_with_length(var1004, 39l); +var1003 = var1005; +varonce1002 = var1003; +} +((struct instance_standard__NativeArray*)var1001)->values[1]=var1003; +if (likely(varonce1006!=NULL)) { +var1007 = varonce1006; +} else { +var1008 = "*sizeof(nitattribute_t));"; +var1009 = standard___standard__NativeString___to_s_with_length(var1008, 25l); +var1007 = var1009; +varonce1006 = var1007; } +((struct instance_standard__NativeArray*)var1001)->values[3]=var1007; +} else { +var1001 = varonce1000; +varonce1000 = NULL; } { -{ /* Inline abstract_compiler#ToolContext#opt_hardening (var7) on */ -var12 = var7->attrs[COLOR_nit__abstract_compiler__ToolContext___opt_hardening].val; /* _opt_hardening on */ -if (unlikely(var12 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_hardening"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 45); -show_backtrace(1); +var1010 = ((val*(*)(val* self))(var_res984->class->vft[COLOR_standard__string__Object__to_s]))(var_res984); /* to_s on */ } -var10 = var12; -RET_LABEL11:(void)0; +((struct instance_standard__NativeArray*)var1001)->values[0]=var1010; +{ +{ /* Inline array#AbstractArrayRead#length (var_attrs) on */ +var1013 = var_attrs->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ +var1011 = var1013; +RET_LABEL1012:(void)0; } } +var1014 = standard__string___Int___Object__to_s(var1011); +((struct instance_standard__NativeArray*)var1001)->values[2]=var1014; { -{ /* Inline opts#Option#value (var10) on */ -var15 = var10->attrs[COLOR_opts__Option___value].val; /* _value on */ -var13 = var15; -RET_LABEL14:(void)0; +var1015 = ((val*(*)(val* self))(var1001->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var1001); /* native_to_s on */ } +varonce1000 = var1001; +{ +nit___nit__AbstractCompilerVisitor___add(var_v, var1015); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -var16 = ((struct instance_standard__Bool*)var13)->value; /* autounbox from nullable Object to Bool */; -var17 = !var16; -if (var17){ -goto RET_LABEL; -} else { } -if (varonce) { -var18 = varonce; +if (unlikely(varonce1016==NULL)) { +var1017 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce1018!=NULL)) { +var1019 = varonce1018; } else { -var19 = "if("; -var20 = 3; -var21 = standard___standard__NativeString___to_s_with_length(var19, var20); -var18 = var21; -varonce = var18; +var1020 = "->type = type;"; +var1021 = standard___standard__NativeString___to_s_with_length(var1020, 14l); +var1019 = var1021; +varonce1018 = var1019; } -if (varonce22) { -var23 = varonce22; +((struct instance_standard__NativeArray*)var1017)->values[1]=var1019; } else { -var24 = " == NULL) {"; -var25 = 11; -var26 = standard___standard__NativeString___to_s_with_length(var24, var25); -var23 = var26; -varonce22 = var23; +var1017 = varonce1016; +varonce1016 = NULL; } -var27 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var27 = array_instance Array[Object] */ -var28 = 3; -var29 = NEW_standard__NativeArray(var28, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var29)->values[0] = (val*) var18; -((struct instance_standard__NativeArray*)var29)->values[1] = (val*) var_t; -((struct instance_standard__NativeArray*)var29)->values[2] = (val*) var23; { -((void (*)(val* self, val* p0, long p1))(var27->class->vft[COLOR_standard__array__Array__with_native]))(var27, var29, var28) /* with_native on */; -} -} -{ -var30 = ((val* (*)(val* self))(var27->class->vft[COLOR_standard__string__Object__to_s]))(var27) /* to_s on */; +var1022 = ((val*(*)(val* self))(var_res984->class->vft[COLOR_standard__string__Object__to_s]))(var_res984); /* to_s on */ } +((struct instance_standard__NativeArray*)var1017)->values[0]=var1022; { -nit___nit__AbstractCompilerVisitor___add(var_v, var30); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ -} -if (varonce31) { -var32 = varonce31; -} else { -var33 = "type null"; -var34 = 9; -var35 = standard___standard__NativeString___to_s_with_length(var33, var34); -var32 = var35; -varonce31 = var32; +var1023 = ((val*(*)(val* self))(var1017->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var1017); /* native_to_s on */ } +varonce1016 = var1017; { -nit___nit__AbstractCompilerVisitor___add_abort(var_v, var32); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_abort on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var1023); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce36) { -var37 = varonce36; +if (likely(varonce1024!=NULL)) { +var1025 = varonce1024; } else { -var38 = "}"; -var39 = 1; -var40 = standard___standard__NativeString___to_s_with_length(var38, var39); -var37 = var40; -varonce36 = var37; +var1026 = "type"; +var1027 = standard___standard__NativeString___to_s_with_length(var1026, 4l); +var1025 = var1027; +varonce1024 = var1025; } { -nit___nit__AbstractCompilerVisitor___add(var_v, var37); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__SeparateCompiler___hardening_live_type(self, var_v, var1025); /* Direct call separate_compiler#SeparateCompiler#hardening_live_type on */ } -if (varonce41) { -var42 = varonce41; +if (unlikely(varonce1028==NULL)) { +var1029 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce1030!=NULL)) { +var1031 = varonce1030; } else { -var43 = "if("; -var44 = 3; -var45 = standard___standard__NativeString___to_s_with_length(var43, var44); -var42 = var45; -varonce41 = var42; +var1032 = "class_"; +var1033 = standard___standard__NativeString___to_s_with_length(var1032, 6l); +var1031 = var1033; +varonce1030 = var1031; } -if (varonce46) { -var47 = varonce46; +((struct instance_standard__NativeArray*)var1029)->values[0]=var1031; } else { -var48 = "->table_size == 0) {"; -var49 = 20; -var50 = standard___standard__NativeString___to_s_with_length(var48, var49); -var47 = var50; -varonce46 = var47; +var1029 = varonce1028; +varonce1028 = NULL; } -var51 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var51 = array_instance Array[Object] */ -var52 = 3; -var53 = NEW_standard__NativeArray(var52, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var53)->values[0] = (val*) var42; -((struct instance_standard__NativeArray*)var53)->values[1] = (val*) var_t; -((struct instance_standard__NativeArray*)var53)->values[2] = (val*) var47; +((struct instance_standard__NativeArray*)var1029)->values[1]=var_c_name; { -((void (*)(val* self, val* p0, long p1))(var51->class->vft[COLOR_standard__array__Array__with_native]))(var51, var53, var52) /* with_native on */; -} +var1034 = ((val*(*)(val* self))(var1029->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var1029); /* native_to_s on */ } +varonce1028 = var1029; { -var54 = ((val* (*)(val* self))(var51->class->vft[COLOR_standard__string__Object__to_s]))(var51) /* to_s on */; +nit___nit__AbstractCompilerVisitor___require_declaration(var_v, var1034); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ } -{ -nit___nit__AbstractCompilerVisitor___add(var_v, var54); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +if (unlikely(varonce1035==NULL)) { +var1036 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce1037!=NULL)) { +var1038 = varonce1037; +} else { +var1039 = "->class = &class_"; +var1040 = standard___standard__NativeString___to_s_with_length(var1039, 17l); +var1038 = var1040; +varonce1037 = var1038; } -if (varonce55) { -var56 = varonce55; +((struct instance_standard__NativeArray*)var1036)->values[1]=var1038; +if (likely(varonce1041!=NULL)) { +var1042 = varonce1041; } else { -var57 = "PRINT_ERROR(\"Insantiation of a dead type: %s\\n\", "; -var58 = 49; -var59 = standard___standard__NativeString___to_s_with_length(var57, var58); -var56 = var59; -varonce55 = var56; +var1043 = ";"; +var1044 = standard___standard__NativeString___to_s_with_length(var1043, 1l); +var1042 = var1044; +varonce1041 = var1042; } -if (varonce60) { -var61 = varonce60; +((struct instance_standard__NativeArray*)var1036)->values[3]=var1042; } else { -var62 = "->name);"; -var63 = 8; -var64 = standard___standard__NativeString___to_s_with_length(var62, var63); -var61 = var64; -varonce60 = var61; +var1036 = varonce1035; +varonce1035 = NULL; } -var65 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var65 = array_instance Array[Object] */ -var66 = 3; -var67 = NEW_standard__NativeArray(var66, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var67)->values[0] = (val*) var56; -((struct instance_standard__NativeArray*)var67)->values[1] = (val*) var_t; -((struct instance_standard__NativeArray*)var67)->values[2] = (val*) var61; { -((void (*)(val* self, val* p0, long p1))(var65->class->vft[COLOR_standard__array__Array__with_native]))(var65, var67, var66) /* with_native on */; -} +var1045 = ((val*(*)(val* self))(var_res984->class->vft[COLOR_standard__string__Object__to_s]))(var_res984); /* to_s on */ } +((struct instance_standard__NativeArray*)var1036)->values[0]=var1045; +((struct instance_standard__NativeArray*)var1036)->values[2]=var_c_name; { -var68 = ((val* (*)(val* self))(var65->class->vft[COLOR_standard__string__Object__to_s]))(var65) /* to_s on */; +var1046 = ((val*(*)(val* self))(var1036->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var1036); /* native_to_s on */ } +varonce1035 = var1036; { -nit___nit__AbstractCompilerVisitor___add(var_v, var68); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(var_v, var1046); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce69) { -var70 = varonce69; +if (var_attrs == NULL) { +var1047 = 0; /* is null */ } else { -var71 = "type dead"; -var72 = 9; -var73 = standard___standard__NativeString___to_s_with_length(var71, var72); -var70 = var73; -varonce69 = var70; +var1047 = 1; /* arg is null and recv is not */ } +if (0) { +{ /* Inline kernel#Object#!= (var_attrs,((val*)NULL)) on */ +var_other = ((val*)NULL); { -nit___nit__AbstractCompilerVisitor___add_abort(var_v, var70); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_abort on */ -} -if (varonce74) { -var75 = varonce74; -} else { -var76 = "}"; -var77 = 1; -var78 = standard___standard__NativeString___to_s_with_length(var76, var77); -var75 = var78; -varonce74 = var75; +var1050 = ((short int(*)(val* self, val* p0))(var_attrs->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_attrs, var_other); /* == on */ } -{ -nit___nit__AbstractCompilerVisitor___add(var_v, var75); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +var1051 = !var1050; +var1048 = var1051; +goto RET_LABEL1049; +RET_LABEL1049:(void)0; } -RET_LABEL:; +var1047 = var1048; } -/* method separate_compiler#SeparateCompiler#new_visitor for (self: SeparateCompiler): SeparateCompilerVisitor */ -val* nit___nit__SeparateCompiler___nit__abstract_compiler__AbstractCompiler__new_visitor(val* self) { -val* var /* : SeparateCompilerVisitor */; -val* var1 /* : SeparateCompilerVisitor */; -short int var2 /* : Bool */; -int cltype; -int idtype; -const struct type* type_struct; -const char* var_class_name; -var1 = NEW_nit__SeparateCompilerVisitor(&type_nit__SeparateCompilerVisitor); +if (var1047){ { -((void (*)(val* self, val* p0))(var1->class->vft[COLOR_nit__abstract_compiler__AbstractCompilerVisitor__compiler_61d]))(var1, self) /* compiler= on */; +nit___nit__AbstractCompiler___generate_init_attr(self, var_v, var_res984, var_mtype); /* Direct call abstract_compiler#AbstractCompiler#generate_init_attr on */ } { -((void (*)(val* self))(var1->class->vft[COLOR_standard__kernel__Object__init]))(var1) /* init on */; +nit___nit__AbstractCompilerVisitor___set_finalizer(var_v, var_res984); /* Direct call abstract_compiler#AbstractCompilerVisitor#set_finalizer on */ } -/* isa VISITOR */ -type_struct = self->type->resolution_table->types[COLOR_nit__abstract_compiler__AbstractCompiler__VISITOR]; -cltype = type_struct->color; -idtype = type_struct->id; -if(cltype >= var1->type->table_size) { -var2 = 0; } else { -var2 = var1->type->type_table[cltype] == idtype; -} -if (unlikely(!var2)) { -var_class_name = var1 == NULL ? "null" : var1->type->name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "VISITOR", var_class_name); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 850); -show_backtrace(1); -} -var = var1; -goto RET_LABEL; -RET_LABEL:; -return var; -} -/* method separate_compiler#SeparateCompiler#type_tables for (self: SeparateCompiler): Map[MType, Array[nullable MType]] */ -val* nit___nit__SeparateCompiler___type_tables(val* self) { -val* var /* : Map[MType, Array[nullable MType]] */; -val* var1 /* : Map[MType, Array[nullable MType]] */; -var1 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___type_tables].val; /* _type_tables on */ -if (unlikely(var1 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _type_tables"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 854); -show_backtrace(1); -} -var = var1; -RET_LABEL:; -return var; } -/* method separate_compiler#SeparateCompiler#type_tables= for (self: SeparateCompiler, Map[MType, Array[nullable MType]]) */ -void nit___nit__SeparateCompiler___type_tables_61d(val* self, val* p0) { -self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___type_tables].val = p0; /* _type_tables on */ -RET_LABEL:; -} -/* method separate_compiler#SeparateCompiler#resolution_tables for (self: SeparateCompiler): Map[MClassType, Array[nullable MType]] */ -val* nit___nit__SeparateCompiler___resolution_tables(val* self) { -val* var /* : Map[MClassType, Array[nullable MType]] */; -val* var1 /* : Map[MClassType, Array[nullable MType]] */; -var1 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___resolution_tables].val; /* _resolution_tables on */ -if (unlikely(var1 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _resolution_tables"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 855); -show_backtrace(1); +if (unlikely(varonce1052==NULL)) { +var1053 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce1054!=NULL)) { +var1055 = varonce1054; +} else { +var1056 = "return "; +var1057 = standard___standard__NativeString___to_s_with_length(var1056, 7l); +var1055 = var1057; +varonce1054 = var1055; } -var = var1; -RET_LABEL:; -return var; +((struct instance_standard__NativeArray*)var1053)->values[0]=var1055; +if (likely(varonce1058!=NULL)) { +var1059 = varonce1058; +} else { +var1060 = ";"; +var1061 = standard___standard__NativeString___to_s_with_length(var1060, 1l); +var1059 = var1061; +varonce1058 = var1059; } -/* method separate_compiler#SeparateCompiler#resolution_tables= for (self: SeparateCompiler, Map[MClassType, Array[nullable MType]]) */ -void nit___nit__SeparateCompiler___resolution_tables_61d(val* self, val* p0) { -self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___resolution_tables].val = p0; /* _resolution_tables on */ -RET_LABEL:; +((struct instance_standard__NativeArray*)var1053)->values[2]=var1059; +} else { +var1053 = varonce1052; +varonce1052 = NULL; } -/* method separate_compiler#SeparateCompiler#method_tables for (self: SeparateCompiler): Map[MClass, Array[nullable MPropDef]] */ -val* nit___nit__SeparateCompiler___method_tables(val* self) { -val* var /* : Map[MClass, Array[nullable MPropDef]] */; -val* var1 /* : Map[MClass, Array[nullable MPropDef]] */; -var1 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___method_tables].val; /* _method_tables on */ -if (unlikely(var1 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _method_tables"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 856); -show_backtrace(1); +{ +var1062 = ((val*(*)(val* self))(var_res984->class->vft[COLOR_standard__string__Object__to_s]))(var_res984); /* to_s on */ } -var = var1; -RET_LABEL:; -return var; +((struct instance_standard__NativeArray*)var1053)->values[1]=var1062; +{ +var1063 = ((val*(*)(val* self))(var1053->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var1053); /* native_to_s on */ } -/* method separate_compiler#SeparateCompiler#method_tables= for (self: SeparateCompiler, Map[MClass, Array[nullable MPropDef]]) */ -void nit___nit__SeparateCompiler___method_tables_61d(val* self, val* p0) { -self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___method_tables].val = p0; /* _method_tables on */ -RET_LABEL:; +varonce1052 = var1053; +{ +nit___nit__AbstractCompilerVisitor___add(var_v, var1063); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -/* method separate_compiler#SeparateCompiler#attr_tables for (self: SeparateCompiler): Map[MClass, Array[nullable MPropDef]] */ -val* nit___nit__SeparateCompiler___attr_tables(val* self) { -val* var /* : Map[MClass, Array[nullable MPropDef]] */; -val* var1 /* : Map[MClass, Array[nullable MPropDef]] */; -var1 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___attr_tables].val; /* _attr_tables on */ -if (unlikely(var1 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _attr_tables"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 857); -show_backtrace(1); } -var = var1; -RET_LABEL:; -return var; +if (likely(varonce1064!=NULL)) { +var1065 = varonce1064; +} else { +var1066 = "}"; +var1067 = standard___standard__NativeString___to_s_with_length(var1066, 1l); +var1065 = var1067; +varonce1064 = var1065; +} +{ +nit___nit__AbstractCompilerVisitor___add(var_v, var1065); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -/* method separate_compiler#SeparateCompiler#attr_tables= for (self: SeparateCompiler, Map[MClass, Array[nullable MPropDef]]) */ -void nit___nit__SeparateCompiler___attr_tables_61d(val* self, val* p0) { -self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___attr_tables].val = p0; /* _attr_tables on */ RET_LABEL:; } -/* method separate_compiler#SeparateCompiler#display_stats for (self: SeparateCompiler) */ -void nit___nit__SeparateCompiler___nit__abstract_compiler__AbstractCompiler__display_stats(val* self) { +/* method separate_compiler#SeparateCompiler#compile_class_infos for (self: SeparateCompiler) */ +void nit___nit__SeparateCompiler___compile_class_infos(val* self) { val* var /* : ModelBuilder */; val* var2 /* : ModelBuilder */; val* var3 /* : ToolContext */; @@ -5057,162 +4910,138 @@ val* var8 /* : OptionBool */; val* var9 /* : nullable Object */; val* var11 /* : nullable Object */; short int var12 /* : Bool */; -val* var13 /* : ModelBuilder */; -val* var15 /* : ModelBuilder */; -val* var16 /* : ToolContext */; -val* var18 /* : ToolContext */; -val* var19 /* : OptionBool */; -val* var21 /* : OptionBool */; -val* var22 /* : nullable Object */; -val* var24 /* : nullable Object */; -short int var25 /* : Bool */; -val* var26 /* : ModelBuilder */; -val* var28 /* : ModelBuilder */; -val* var29 /* : ToolContext */; -val* var31 /* : ToolContext */; -val* var_tc /* var tc: ToolContext */; +val* var13 /* : Array[nullable MClass] */; +val* var_class_info /* var class_info: Array[nullable MClass] */; +val* var14 /* : HashMap[MClass, Int] */; +val* var16 /* : HashMap[MClass, Int] */; +val* var17 /* : RemovableCollection[nullable Object] */; +val* var_ /* var : RemovableCollection[MClass] */; +val* var18 /* : Iterator[nullable Object] */; +val* var_19 /* var : Iterator[MClass] */; +short int var20 /* : Bool */; +val* var21 /* : nullable Object */; +val* var_t /* var t: MClass */; +val* var22 /* : String */; +val* var24 /* : String */; static val* varonce; -val* var32 /* : String */; -char* var33 /* : NativeString */; -long var34 /* : Int */; +val* var25 /* : String */; +char* var26 /* : NativeString */; +val* var27 /* : FlatString */; +short int var28 /* : Bool */; +val* var29 /* : String */; +val* var31 /* : String */; +static val* varonce32; +val* var33 /* : String */; +char* var34 /* : NativeString */; val* var35 /* : FlatString */; -long var36 /* : Int */; -val* var37 /* : ModelBuilder */; -val* var39 /* : ModelBuilder */; -long var40 /* : Int */; -long var42 /* : Int */; -val* var43 /* : ModelBuilder */; -val* var45 /* : ModelBuilder */; -long var46 /* : Int */; -long var48 /* : Int */; -long var49 /* : Int */; -short int var51 /* : Bool */; -int cltype; -int idtype; -const char* var_class_name; -long var52 /* : Int */; -val* var53 /* : ModelBuilder */; -val* var55 /* : ModelBuilder */; -long var56 /* : Int */; -long var58 /* : Int */; -long var59 /* : Int */; +short int var36 /* : Bool */; +val* var37 /* : String */; +val* var39 /* : String */; +static val* varonce40; +val* var41 /* : String */; +char* var42 /* : NativeString */; +val* var43 /* : FlatString */; +short int var44 /* : Bool */; +val* var45 /* : MClassType */; +val* var47 /* : MClassType */; +val* var50 /* : AbstractCompilerVisitor */; +val* var_v /* var v: SeparateCompilerVisitor */; +static val* varonce51; +val* var52 /* : String */; +char* var53 /* : NativeString */; +val* var54 /* : FlatString */; +val* var_55 /* var : Array[nullable MClass] */; +val* var56 /* : ArrayIterator[nullable Object] */; +val* var_57 /* var : ArrayIterator[nullable MClass] */; +short int var58 /* : Bool */; +val* var59 /* : nullable Object */; +val* var_t60 /* var t: nullable MClass */; short int var61 /* : Bool */; -int cltype62; -int idtype63; -const char* var_class_name64; -long var65 /* : Int */; -long var_nb_invok_total /* var nb_invok_total: Int */; -static val* varonce66; -val* var67 /* : String */; -char* var68 /* : NativeString */; -long var69 /* : Int */; +short int var62 /* : Bool */; +val* var_other /* var other: nullable Object */; +short int var64 /* : Bool */; +short int var66 /* : Bool */; +static val* varonce67; +val* var68 /* : String */; +char* var69 /* : NativeString */; val* var70 /* : FlatString */; -val* var71 /* : Array[Object] */; -long var72 /* : Int */; -val* var73 /* : NativeArray[Object] */; -val* var74 /* : Object */; -val* var75 /* : String */; -long var76 /* : Int */; -static val* varonce77; +val* var72 /* : NativeArray[String] */; +static val* varonce71; +static val* varonce73; +val* var74 /* : String */; +char* var75 /* : NativeString */; +val* var76 /* : FlatString */; +val* var77 /* : String */; val* var78 /* : String */; -char* var79 /* : NativeString */; -long var80 /* : Int */; -val* var81 /* : FlatString */; -val* var82 /* : ModelBuilder */; -val* var84 /* : ModelBuilder */; -long var85 /* : Int */; -long var87 /* : Int */; -static val* varonce88; +val* var_s /* var s: String */; +val* var80 /* : NativeArray[String] */; +static val* varonce79; +static val* varonce81; +val* var82 /* : String */; +char* var83 /* : NativeString */; +val* var84 /* : FlatString */; +static val* varonce85; +val* var86 /* : String */; +char* var87 /* : NativeString */; +val* var88 /* : FlatString */; val* var89 /* : String */; -char* var90 /* : NativeString */; -long var91 /* : Int */; -val* var92 /* : FlatString */; -val* var93 /* : ModelBuilder */; -val* var95 /* : ModelBuilder */; -long var96 /* : Int */; -long var98 /* : Int */; -val* var99 /* : String */; -static val* varonce100; -val* var101 /* : String */; -char* var102 /* : NativeString */; -long var103 /* : Int */; -val* var104 /* : FlatString */; -val* var105 /* : Array[Object] */; -long var106 /* : Int */; -val* var107 /* : NativeArray[Object] */; -val* var108 /* : Object */; -val* var109 /* : String */; -long var110 /* : Int */; +static val* varonce91; +val* var92 /* : String */; +char* var93 /* : NativeString */; +val* var94 /* : FlatString */; +static val* varonce95; +val* var96 /* : String */; +char* var97 /* : NativeString */; +val* var98 /* : FlatString */; +val* var_99 /* var : Array[nullable MClass] */; +val* var100 /* : ArrayIterator[nullable Object] */; +val* var_101 /* var : ArrayIterator[nullable MClass] */; +short int var102 /* : Bool */; +val* var103 /* : nullable Object */; +val* var_t104 /* var t: nullable MClass */; +short int var105 /* : Bool */; +short int var106 /* : Bool */; +short int var108 /* : Bool */; +short int var110 /* : Bool */; static val* varonce111; val* var112 /* : String */; char* var113 /* : NativeString */; -long var114 /* : Int */; -val* var115 /* : FlatString */; -val* var116 /* : ModelBuilder */; -val* var118 /* : ModelBuilder */; -long var119 /* : Int */; -long var121 /* : Int */; -static val* varonce122; -val* var123 /* : String */; -char* var124 /* : NativeString */; -long var125 /* : Int */; -val* var126 /* : FlatString */; -val* var127 /* : ModelBuilder */; -val* var129 /* : ModelBuilder */; -long var130 /* : Int */; -long var132 /* : Int */; +val* var114 /* : FlatString */; +val* var116 /* : NativeArray[String] */; +static val* varonce115; +static val* varonce117; +val* var118 /* : String */; +char* var119 /* : NativeString */; +val* var120 /* : FlatString */; +val* var121 /* : String */; +val* var122 /* : String */; +val* var_s123 /* var s: String */; +val* var124 /* : Set[MType] */; +val* var126 /* : Set[MType] */; +val* var127 /* : MClassType */; +val* var129 /* : MClassType */; +val* var131 /* : NativeArray[String] */; +static val* varonce130; +static val* varonce132; val* var133 /* : String */; -static val* varonce134; -val* var135 /* : String */; -char* var136 /* : NativeString */; -long var137 /* : Int */; -val* var138 /* : FlatString */; -val* var139 /* : Array[Object] */; -long var140 /* : Int */; -val* var141 /* : NativeArray[Object] */; -val* var142 /* : Object */; +char* var134 /* : NativeString */; +val* var135 /* : FlatString */; +static val* varonce136; +val* var137 /* : String */; +char* var138 /* : NativeString */; +val* var139 /* : FlatString */; +val* var140 /* : String */; +static val* varonce142; val* var143 /* : String */; -long var144 /* : Int */; -static val* varonce145; -val* var146 /* : String */; -char* var147 /* : NativeString */; -long var148 /* : Int */; -val* var149 /* : FlatString */; -val* var150 /* : ModelBuilder */; -val* var152 /* : ModelBuilder */; -long var153 /* : Int */; -long var155 /* : Int */; -static val* varonce156; -val* var157 /* : String */; -char* var158 /* : NativeString */; -long var159 /* : Int */; -val* var160 /* : FlatString */; -val* var161 /* : ModelBuilder */; -val* var163 /* : ModelBuilder */; -long var164 /* : Int */; -long var166 /* : Int */; -val* var167 /* : String */; -static val* varonce168; -val* var169 /* : String */; -char* var170 /* : NativeString */; -long var171 /* : Int */; -val* var172 /* : FlatString */; -val* var173 /* : Array[Object] */; -long var174 /* : Int */; -val* var175 /* : NativeArray[Object] */; -val* var176 /* : Object */; -val* var177 /* : String */; -long var178 /* : Int */; -{ -((void (*)(val* self))(self->class->vft[COLOR_nit___nit__SeparateCompiler___nit__abstract_compiler__AbstractCompiler__display_stats]))(self) /* display_stats on */; -} +char* var144 /* : NativeString */; +val* var145 /* : FlatString */; { { /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ var2 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ if (unlikely(var2 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 522); +fatal_exit(1); } var = var2; RET_LABEL1:(void)0; @@ -5224,19 +5053,19 @@ var5 = var->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; if (unlikely(var5 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47); -show_backtrace(1); +fatal_exit(1); } var3 = var5; RET_LABEL4:(void)0; } } { -{ /* Inline separate_compiler#ToolContext#opt_tables_metrics (var3) on */ -var8 = var3->attrs[COLOR_nit__separate_compiler__ToolContext___opt_tables_metrics].val; /* _opt_tables_metrics on */ +{ /* Inline separate_compiler#ToolContext#opt_no_tag_primitives (var3) on */ +var8 = var3->attrs[COLOR_nit__separate_compiler__ToolContext___opt_no_tag_primitives].val; /* _opt_no_tag_primitives on */ if (unlikely(var8 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_tables_metrics"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 47); -show_backtrace(1); +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_no_tag_primitives"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 32); +fatal_exit(1); } var6 = var8; RET_LABEL7:(void)0; @@ -5249,4301 +5078,3658 @@ var9 = var11; RET_LABEL10:(void)0; } } -var12 = ((struct instance_standard__Bool*)var9)->value; /* autounbox from nullable Object to Bool */; +var12 = (short int)((long)(var9)>>2); if (var12){ -{ -((void (*)(val* self))(self->class->vft[COLOR_nit__separate_compiler__SeparateCompiler__display_sizes]))(self) /* display_sizes on */; -} +goto RET_LABEL; } else { } +var13 = NEW_standard__Array(&type_standard__Array__nullable__nit__MClass); { -{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ -var15 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ -if (unlikely(var15 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); -show_backtrace(1); -} -var13 = var15; -RET_LABEL14:(void)0; -} +standard___standard__Array___filled_with(var13, ((val*)NULL), 4l); /* Direct call array#Array#filled_with on */ } +var_class_info = var13; { -{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var13) on */ -var18 = var13->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ -if (unlikely(var18 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47); -show_backtrace(1); +{ /* Inline separate_compiler#SeparateCompiler#box_kinds (self) on */ +var16 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___box_kinds].val; /* _box_kinds on */ +if (unlikely(var16 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _box_kinds"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 263); +fatal_exit(1); } -var16 = var18; -RET_LABEL17:(void)0; +var14 = var16; +RET_LABEL15:(void)0; } } { -{ /* Inline abstract_compiler#ToolContext#opt_isset_checks_metrics (var16) on */ -var21 = var16->attrs[COLOR_nit__abstract_compiler__ToolContext___opt_isset_checks_metrics].val; /* _opt_isset_checks_metrics on */ -if (unlikely(var21 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_isset_checks_metrics"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 63); -show_backtrace(1); +var17 = standard___standard__HashMap___standard__abstract_collection__MapRead__keys(var14); } -var19 = var21; -RET_LABEL20:(void)0; +var_ = var17; +{ +var18 = ((val*(*)(val* self))((((long)var_&3)?class_info[((long)var_&3)]:var_->class)->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_); /* iterator on */ +} +var_19 = var18; +for(;;) { +{ +var20 = ((short int(*)(val* self))((((long)var_19&3)?class_info[((long)var_19&3)]:var_19->class)->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_19); /* is_ok on */ } +if (var20){ +{ +var21 = ((val*(*)(val* self))((((long)var_19&3)?class_info[((long)var_19&3)]:var_19->class)->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_19); /* item on */ } +var_t = var21; { -{ /* Inline opts#Option#value (var19) on */ -var24 = var19->attrs[COLOR_opts__Option___value].val; /* _value on */ +{ /* Inline model#MClass#name (var_t) on */ +var24 = var_t->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ +if (unlikely(var24 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 362); +fatal_exit(1); +} var22 = var24; RET_LABEL23:(void)0; } } -var25 = ((struct instance_standard__Bool*)var22)->value; /* autounbox from nullable Object to Bool */; -if (var25){ -{ -nit___nit__SeparateCompiler___display_isset_checks(self); /* Direct call separate_compiler#SeparateCompiler#display_isset_checks on */ -} +if (likely(varonce!=NULL)) { +var25 = varonce; } else { +var26 = "Int"; +var27 = standard___standard__NativeString___to_s_with_length(var26, 3l); +var25 = var27; +varonce = var25; } { -{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ -var28 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ -if (unlikely(var28 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); -show_backtrace(1); -} -var26 = var28; -RET_LABEL27:(void)0; +var28 = ((short int(*)(val* self, val* p0))(var22->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var22, var25); /* == on */ } +if (var28){ +{ +standard___standard__Array___standard__abstract_collection__Sequence___91d_93d_61d(var_class_info, 1l, var_t); /* Direct call array#Array#[]= on */ } +} else { { -{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var26) on */ -var31 = var26->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ +{ /* Inline model#MClass#name (var_t) on */ +var31 = var_t->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ if (unlikely(var31 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47); -show_backtrace(1); +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 362); +fatal_exit(1); } var29 = var31; RET_LABEL30:(void)0; } } -var_tc = var29; -if (varonce) { -var32 = varonce; +if (likely(varonce32!=NULL)) { +var33 = varonce32; } else { -var33 = "# implementation of method invocation"; -var34 = 37; -var35 = standard___standard__NativeString___to_s_with_length(var33, var34); -var32 = var35; -varonce = var32; +var34 = "Char"; +var35 = standard___standard__NativeString___to_s_with_length(var34, 4l); +var33 = var35; +varonce32 = var33; } -var36 = 2; { -nit___nit__ToolContext___info(var_tc, var32, var36); /* Direct call toolcontext#ToolContext#info on */ +var36 = ((short int(*)(val* self, val* p0))(var29->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var29, var33); /* == on */ } +if (var36){ { -{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ -var39 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +standard___standard__Array___standard__abstract_collection__Sequence___91d_93d_61d(var_class_info, 2l, var_t); /* Direct call array#Array#[]= on */ +} +} else { +{ +{ /* Inline model#MClass#name (var_t) on */ +var39 = var_t->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ if (unlikely(var39 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); -show_backtrace(1); +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 362); +fatal_exit(1); } var37 = var39; RET_LABEL38:(void)0; } } +if (likely(varonce40!=NULL)) { +var41 = varonce40; +} else { +var42 = "Bool"; +var43 = standard___standard__NativeString___to_s_with_length(var42, 4l); +var41 = var43; +varonce40 = var41; +} +{ +var44 = ((short int(*)(val* self, val* p0))(var37->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var37, var41); /* == on */ +} +if (var44){ { -{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_tables (var37) on */ -var42 = var37->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_tables].l; /* _nb_invok_by_tables on */ -var40 = var42; -RET_LABEL41:(void)0; +standard___standard__Array___standard__abstract_collection__Sequence___91d_93d_61d(var_class_info, 3l, var_t); /* Direct call array#Array#[]= on */ +} +} else { +goto BREAK_label; +} } } { -{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ -var45 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ -if (unlikely(var45 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); -show_backtrace(1); +{ /* Inline model#MClass#mclass_type (var_t) on */ +var47 = var_t->attrs[COLOR_nit__model__MClass___mclass_type].val; /* _mclass_type on */ +if (unlikely(var47 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass_type"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 484); +fatal_exit(1); } -var43 = var45; -RET_LABEL44:(void)0; +var45 = var47; +RET_LABEL46:(void)0; } } { -{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_direct (var43) on */ -var48 = var43->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_direct].l; /* _nb_invok_by_direct on */ -var46 = var48; -RET_LABEL47:(void)0; +{ /* Inline separate_compiler#MType#is_tagged= (var45,1) on */ +var45->attrs[COLOR_nit__separate_compiler__MType___is_tagged].s = 1; /* _is_tagged on */ +RET_LABEL48:(void)0; } } +BREAK_label: (void)0; { -{ /* Inline kernel#Int#+ (var40,var46) on */ -/* Covariant cast for argument 0 (i) isa OTHER */ -/* isa OTHER */ -var51 = 1; /* easy isa OTHER*/ -if (unlikely(!var51)) { -var_class_name = type_standard__Int.name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); -PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413); -show_backtrace(1); +((void(*)(val* self))((((long)var_19&3)?class_info[((long)var_19&3)]:var_19->class)->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_19); /* next on */ +} +} else { +goto BREAK_label49; } -var52 = var40 + var46; -var49 = var52; -goto RET_LABEL50; -RET_LABEL50:(void)0; } +BREAK_label49: (void)0; +{ +((void(*)(val* self))((((long)var_19&3)?class_info[((long)var_19&3)]:var_19->class)->vft[COLOR_standard__abstract_collection__Iterator__finish]))(var_19); /* finish on */ } { -{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ -var55 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ -if (unlikely(var55 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); -show_backtrace(1); +var50 = ((val*(*)(val* self))(self->class->vft[COLOR_nit__abstract_compiler__AbstractCompiler__new_visitor]))(self); /* new_visitor on */ +} +var_v = var50; +if (likely(varonce51!=NULL)) { +var52 = varonce51; +} else { +var53 = "const struct class *class_info[4] = {"; +var54 = standard___standard__NativeString___to_s_with_length(var53, 37l); +var52 = var54; +varonce51 = var52; +} +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var52); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +var_55 = var_class_info; +{ +var56 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_55); +} +var_57 = var56; +for(;;) { +{ +var58 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_57); +} +if (var58){ +{ +var59 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_57); +} +var_t60 = var59; +if (var_t60 == NULL) { +var61 = 1; /* is null */ +} else { +var61 = 0; /* arg is null but recv is not */ +} +if (0) { +{ /* Inline kernel#Object#== (var_t60,((val*)NULL)) on */ +var_other = ((val*)NULL); +{ +{ /* Inline kernel#Object#is_same_instance (var_t60,var_other) on */ +var66 = var_t60 == var_other; +var64 = var66; +goto RET_LABEL65; +RET_LABEL65:(void)0; +} +} +var62 = var64; +goto RET_LABEL63; +RET_LABEL63:(void)0; } -var53 = var55; -RET_LABEL54:(void)0; +var61 = var62; } +if (var61){ +if (likely(varonce67!=NULL)) { +var68 = varonce67; +} else { +var69 = "NULL,"; +var70 = standard___standard__NativeString___to_s_with_length(var69, 5l); +var68 = var70; +varonce67 = var68; } { -{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_inline (var53) on */ -var58 = var53->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_inline].l; /* _nb_invok_by_inline on */ -var56 = var58; -RET_LABEL57:(void)0; +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var68); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +} +} else { +if (unlikely(varonce71==NULL)) { +var72 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce73!=NULL)) { +var74 = varonce73; +} else { +var75 = "class_"; +var76 = standard___standard__NativeString___to_s_with_length(var75, 6l); +var74 = var76; +varonce73 = var74; } +((struct instance_standard__NativeArray*)var72)->values[0]=var74; +} else { +var72 = varonce71; +varonce71 = NULL; } { -{ /* Inline kernel#Int#+ (var49,var56) on */ -/* Covariant cast for argument 0 (i) isa OTHER */ -/* isa OTHER */ -var61 = 1; /* easy isa OTHER*/ -if (unlikely(!var61)) { -var_class_name64 = type_standard__Int.name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name64); -PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413); -show_backtrace(1); +var77 = nit___nit__MClass___nit__model_base__MEntity__c_name(var_t60); } -var65 = var49 + var56; -var59 = var65; -goto RET_LABEL60; -RET_LABEL60:(void)0; +((struct instance_standard__NativeArray*)var72)->values[1]=var77; +{ +var78 = ((val*(*)(val* self))(var72->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var72); /* native_to_s on */ } +varonce71 = var72; +var_s = var78; +{ +nit___nit__AbstractCompilerVisitor___require_declaration(var_v, var_s); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ } -var_nb_invok_total = var59; -if (varonce66) { -var67 = varonce66; +if (unlikely(varonce79==NULL)) { +var80 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce81!=NULL)) { +var82 = varonce81; } else { -var68 = "total number of invocations: "; -var69 = 29; -var70 = standard___standard__NativeString___to_s_with_length(var68, var69); -var67 = var70; -varonce66 = var67; +var83 = "&"; +var84 = standard___standard__NativeString___to_s_with_length(var83, 1l); +var82 = var84; +varonce81 = var82; } -var71 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var71 = array_instance Array[Object] */ -var72 = 2; -var73 = NEW_standard__NativeArray(var72, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var73)->values[0] = (val*) var67; -var74 = BOX_standard__Int(var_nb_invok_total); /* autobox from Int to Object */ -((struct instance_standard__NativeArray*)var73)->values[1] = (val*) var74; -{ -((void (*)(val* self, val* p0, long p1))(var71->class->vft[COLOR_standard__array__Array__with_native]))(var71, var73, var72) /* with_native on */; +((struct instance_standard__NativeArray*)var80)->values[0]=var82; +if (likely(varonce85!=NULL)) { +var86 = varonce85; +} else { +var87 = ","; +var88 = standard___standard__NativeString___to_s_with_length(var87, 1l); +var86 = var88; +varonce85 = var86; } +((struct instance_standard__NativeArray*)var80)->values[2]=var86; +} else { +var80 = varonce79; +varonce79 = NULL; } +((struct instance_standard__NativeArray*)var80)->values[1]=var_s; { -var75 = ((val* (*)(val* self))(var71->class->vft[COLOR_standard__string__Object__to_s]))(var71) /* to_s on */; +var89 = ((val*(*)(val* self))(var80->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var80); /* native_to_s on */ } -var76 = 2; +varonce79 = var80; { -nit___nit__ToolContext___info(var_tc, var75, var76); /* Direct call toolcontext#ToolContext#info on */ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var89); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } -if (varonce77) { -var78 = varonce77; -} else { -var79 = "invocations by VFT send: "; -var80 = 29; -var81 = standard___standard__NativeString___to_s_with_length(var79, var80); -var78 = var81; -varonce77 = var78; } { -{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ -var84 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ -if (unlikely(var84 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); -show_backtrace(1); +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_57); /* Direct call array#ArrayIterator#next on */ } -var82 = var84; -RET_LABEL83:(void)0; +} else { +goto BREAK_label90; } } +BREAK_label90: (void)0; { -{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_tables (var82) on */ -var87 = var82->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_tables].l; /* _nb_invok_by_tables on */ -var85 = var87; -RET_LABEL86:(void)0; -} +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__finish(var_57); /* Direct call array#ArrayIterator#finish on */ } -if (varonce88) { -var89 = varonce88; +if (likely(varonce91!=NULL)) { +var92 = varonce91; } else { -var90 = " ("; -var91 = 2; -var92 = standard___standard__NativeString___to_s_with_length(var90, var91); -var89 = var92; -varonce88 = var89; +var93 = "};"; +var94 = standard___standard__NativeString___to_s_with_length(var93, 2l); +var92 = var94; +varonce91 = var92; } { -{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ -var95 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ -if (unlikely(var95 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); -show_backtrace(1); +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var92); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } -var93 = var95; -RET_LABEL94:(void)0; +if (likely(varonce95!=NULL)) { +var96 = varonce95; +} else { +var97 = "const struct type *type_info[4] = {"; +var98 = standard___standard__NativeString___to_s_with_length(var97, 35l); +var96 = var98; +varonce95 = var96; } +{ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var96); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } +var_99 = var_class_info; { -{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_tables (var93) on */ -var98 = var93->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_tables].l; /* _nb_invok_by_tables on */ -var96 = var98; -RET_LABEL97:(void)0; +var100 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_99); } +var_101 = var100; +for(;;) { +{ +var102 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_101); } +if (var102){ { -var99 = nit___nit__AbstractCompiler___div(self, var96, var_nb_invok_total); +var103 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_101); } -if (varonce100) { -var101 = varonce100; +var_t104 = var103; +if (var_t104 == NULL) { +var105 = 1; /* is null */ } else { -var102 = "%)"; -var103 = 2; -var104 = standard___standard__NativeString___to_s_with_length(var102, var103); -var101 = var104; -varonce100 = var101; +var105 = 0; /* arg is null but recv is not */ } -var105 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var105 = array_instance Array[Object] */ -var106 = 5; -var107 = NEW_standard__NativeArray(var106, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var107)->values[0] = (val*) var78; -var108 = BOX_standard__Int(var85); /* autobox from Int to Object */ -((struct instance_standard__NativeArray*)var107)->values[1] = (val*) var108; -((struct instance_standard__NativeArray*)var107)->values[2] = (val*) var89; -((struct instance_standard__NativeArray*)var107)->values[3] = (val*) var99; -((struct instance_standard__NativeArray*)var107)->values[4] = (val*) var101; +if (0) { +{ /* Inline kernel#Object#== (var_t104,((val*)NULL)) on */ +var_other = ((val*)NULL); { -((void (*)(val* self, val* p0, long p1))(var105->class->vft[COLOR_standard__array__Array__with_native]))(var105, var107, var106) /* with_native on */; +{ /* Inline kernel#Object#is_same_instance (var_t104,var_other) on */ +var110 = var_t104 == var_other; +var108 = var110; +goto RET_LABEL109; +RET_LABEL109:(void)0; } } -{ -var109 = ((val* (*)(val* self))(var105->class->vft[COLOR_standard__string__Object__to_s]))(var105) /* to_s on */; +var106 = var108; +goto RET_LABEL107; +RET_LABEL107:(void)0; } -var110 = 2; -{ -nit___nit__ToolContext___info(var_tc, var109, var110); /* Direct call toolcontext#ToolContext#info on */ +var105 = var106; } -if (varonce111) { +if (var105){ +if (likely(varonce111!=NULL)) { var112 = varonce111; } else { -var113 = "invocations by direct call: "; -var114 = 29; -var115 = standard___standard__NativeString___to_s_with_length(var113, var114); -var112 = var115; +var113 = "NULL,"; +var114 = standard___standard__NativeString___to_s_with_length(var113, 5l); +var112 = var114; varonce111 = var112; } { -{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ -var118 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ -if (unlikely(var118 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); -show_backtrace(1); +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var112); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } -var116 = var118; -RET_LABEL117:(void)0; +} else { +if (unlikely(varonce115==NULL)) { +var116 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce117!=NULL)) { +var118 = varonce117; +} else { +var119 = "type_"; +var120 = standard___standard__NativeString___to_s_with_length(var119, 5l); +var118 = var120; +varonce117 = var118; } +((struct instance_standard__NativeArray*)var116)->values[0]=var118; +} else { +var116 = varonce115; +varonce115 = NULL; } { -{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_direct (var116) on */ -var121 = var116->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_direct].l; /* _nb_invok_by_direct on */ -var119 = var121; -RET_LABEL120:(void)0; +var121 = nit___nit__MClass___nit__model_base__MEntity__c_name(var_t104); +} +((struct instance_standard__NativeArray*)var116)->values[1]=var121; +{ +var122 = ((val*(*)(val* self))(var116->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var116); /* native_to_s on */ } +varonce115 = var116; +var_s123 = var122; +{ +{ /* Inline separate_compiler#SeparateCompiler#undead_types (self) on */ +var126 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___undead_types].val; /* _undead_types on */ +if (unlikely(var126 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _undead_types"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 146); +fatal_exit(1); +} +var124 = var126; +RET_LABEL125:(void)0; } -if (varonce122) { -var123 = varonce122; -} else { -var124 = " ("; -var125 = 2; -var126 = standard___standard__NativeString___to_s_with_length(var124, var125); -var123 = var126; -varonce122 = var123; } { -{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ -var129 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +{ /* Inline model#MClass#mclass_type (var_t104) on */ +var129 = var_t104->attrs[COLOR_nit__model__MClass___mclass_type].val; /* _mclass_type on */ if (unlikely(var129 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); -show_backtrace(1); +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass_type"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 484); +fatal_exit(1); } var127 = var129; RET_LABEL128:(void)0; } } { -{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_direct (var127) on */ -var132 = var127->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_direct].l; /* _nb_invok_by_direct on */ -var130 = var132; -RET_LABEL131:(void)0; -} +((void(*)(val* self, val* p0))((((long)var124&3)?class_info[((long)var124&3)]:var124->class)->vft[COLOR_standard__abstract_collection__SimpleCollection__add]))(var124, var127); /* add on */ } { -var133 = nit___nit__AbstractCompiler___div(self, var130, var_nb_invok_total); +nit___nit__AbstractCompilerVisitor___require_declaration(var_v, var_s123); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ } -if (varonce134) { -var135 = varonce134; +if (unlikely(varonce130==NULL)) { +var131 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce132!=NULL)) { +var133 = varonce132; } else { -var136 = "%)"; -var137 = 2; -var138 = standard___standard__NativeString___to_s_with_length(var136, var137); -var135 = var138; -varonce134 = var135; -} -var139 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var139 = array_instance Array[Object] */ -var140 = 5; -var141 = NEW_standard__NativeArray(var140, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var141)->values[0] = (val*) var112; -var142 = BOX_standard__Int(var119); /* autobox from Int to Object */ -((struct instance_standard__NativeArray*)var141)->values[1] = (val*) var142; -((struct instance_standard__NativeArray*)var141)->values[2] = (val*) var123; -((struct instance_standard__NativeArray*)var141)->values[3] = (val*) var133; -((struct instance_standard__NativeArray*)var141)->values[4] = (val*) var135; -{ -((void (*)(val* self, val* p0, long p1))(var139->class->vft[COLOR_standard__array__Array__with_native]))(var139, var141, var140) /* with_native on */; -} -} -{ -var143 = ((val* (*)(val* self))(var139->class->vft[COLOR_standard__string__Object__to_s]))(var139) /* to_s on */; +var134 = "&"; +var135 = standard___standard__NativeString___to_s_with_length(var134, 1l); +var133 = var135; +varonce132 = var133; } -var144 = 2; -{ -nit___nit__ToolContext___info(var_tc, var143, var144); /* Direct call toolcontext#ToolContext#info on */ -} -if (varonce145) { -var146 = varonce145; +((struct instance_standard__NativeArray*)var131)->values[0]=var133; +if (likely(varonce136!=NULL)) { +var137 = varonce136; } else { -var147 = "invocations by inlining: "; -var148 = 29; -var149 = standard___standard__NativeString___to_s_with_length(var147, var148); -var146 = var149; -varonce145 = var146; -} -{ -{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ -var152 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ -if (unlikely(var152 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); -show_backtrace(1); -} -var150 = var152; -RET_LABEL151:(void)0; -} +var138 = ","; +var139 = standard___standard__NativeString___to_s_with_length(var138, 1l); +var137 = var139; +varonce136 = var137; } -{ -{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_inline (var150) on */ -var155 = var150->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_inline].l; /* _nb_invok_by_inline on */ -var153 = var155; -RET_LABEL154:(void)0; -} -} -if (varonce156) { -var157 = varonce156; +((struct instance_standard__NativeArray*)var131)->values[2]=var137; } else { -var158 = " ("; -var159 = 2; -var160 = standard___standard__NativeString___to_s_with_length(var158, var159); -var157 = var160; -varonce156 = var157; +var131 = varonce130; +varonce130 = NULL; } +((struct instance_standard__NativeArray*)var131)->values[1]=var_s123; { -{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ -var163 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ -if (unlikely(var163 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); -show_backtrace(1); -} -var161 = var163; -RET_LABEL162:(void)0; -} +var140 = ((val*(*)(val* self))(var131->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var131); /* native_to_s on */ } +varonce130 = var131; { -{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_inline (var161) on */ -var166 = var161->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_inline].l; /* _nb_invok_by_inline on */ -var164 = var166; -RET_LABEL165:(void)0; +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var140); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } } { -var167 = nit___nit__AbstractCompiler___div(self, var164, var_nb_invok_total); +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_101); /* Direct call array#ArrayIterator#next on */ } -if (varonce168) { -var169 = varonce168; } else { -var170 = "%)"; -var171 = 2; -var172 = standard___standard__NativeString___to_s_with_length(var170, var171); -var169 = var172; -varonce168 = var169; -} -var173 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var173 = array_instance Array[Object] */ -var174 = 5; -var175 = NEW_standard__NativeArray(var174, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var175)->values[0] = (val*) var146; -var176 = BOX_standard__Int(var153); /* autobox from Int to Object */ -((struct instance_standard__NativeArray*)var175)->values[1] = (val*) var176; -((struct instance_standard__NativeArray*)var175)->values[2] = (val*) var157; -((struct instance_standard__NativeArray*)var175)->values[3] = (val*) var167; -((struct instance_standard__NativeArray*)var175)->values[4] = (val*) var169; -{ -((void (*)(val* self, val* p0, long p1))(var173->class->vft[COLOR_standard__array__Array__with_native]))(var173, var175, var174) /* with_native on */; +goto BREAK_label141; } } +BREAK_label141: (void)0; { -var177 = ((val* (*)(val* self))(var173->class->vft[COLOR_standard__string__Object__to_s]))(var173) /* to_s on */; +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__finish(var_101); /* Direct call array#ArrayIterator#finish on */ +} +if (likely(varonce142!=NULL)) { +var143 = varonce142; +} else { +var144 = "};"; +var145 = standard___standard__NativeString___to_s_with_length(var144, 2l); +var143 = var145; +varonce142 = var143; } -var178 = 2; { -nit___nit__ToolContext___info(var_tc, var177, var178); /* Direct call toolcontext#ToolContext#info on */ +nit___nit__AbstractCompilerVisitor___add_decl(var_v, var143); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } RET_LABEL:; } -/* method separate_compiler#SeparateCompiler#display_sizes for (self: SeparateCompiler) */ -void nit___nit__SeparateCompiler___display_sizes(val* self) { -static val* varonce; -val* var /* : String */; -char* var1 /* : NativeString */; -long var2 /* : Int */; -val* var3 /* : FlatString */; -static val* varonce4; -val* var5 /* : String */; -char* var6 /* : NativeString */; -long var7 /* : Int */; -val* var8 /* : FlatString */; -long var9 /* : Int */; -long var_total /* var total: Int */; -long var10 /* : Int */; -long var_holes /* var holes: Int */; -val* var11 /* : Map[MType, Array[nullable MType]] */; -val* var13 /* : Map[MType, Array[nullable MType]] */; -val* var_ /* var : Map[MType, Array[nullable MType]] */; -val* var14 /* : MapIterator[nullable Object, nullable Object] */; -val* var_15 /* var : MapIterator[MType, Array[nullable MType]] */; -short int var16 /* : Bool */; -val* var17 /* : nullable Object */; -val* var_t /* var t: MType */; -val* var18 /* : nullable Object */; -val* var_table /* var table: Array[nullable MType] */; -long var19 /* : Int */; -long var21 /* : Int */; -long var22 /* : Int */; -short int var24 /* : Bool */; +/* method separate_compiler#SeparateCompiler#hardening_live_type for (self: SeparateCompiler, SeparateCompilerVisitor, String) */ +void nit___nit__SeparateCompiler___hardening_live_type(val* self, val* p0, val* p1) { +short int var /* : Bool */; int cltype; int idtype; +const struct type* type_struct; const char* var_class_name; -long var25 /* : Int */; -val* var_26 /* var : Array[nullable MType] */; -val* var27 /* : ArrayIterator[nullable Object] */; -val* var_28 /* var : ArrayIterator[nullable MType] */; -short int var29 /* : Bool */; -val* var30 /* : nullable Object */; -val* var_e /* var e: nullable MType */; -val* var31 /* : null */; -short int var32 /* : Bool */; -short int var33 /* : Bool */; -val* var_other /* var other: nullable Object */; -short int var35 /* : Bool */; -short int var37 /* : Bool */; -long var38 /* : Int */; -long var39 /* : Int */; -short int var41 /* : Bool */; -int cltype42; -int idtype43; -const char* var_class_name44; -long var45 /* : Int */; +val* var_v /* var v: SeparateCompilerVisitor */; +val* var_t /* var t: String */; +val* var1 /* : AbstractCompiler */; +val* var3 /* : AbstractCompiler */; +val* var4 /* : ModelBuilder */; +val* var6 /* : ModelBuilder */; +val* var7 /* : ToolContext */; +val* var9 /* : ToolContext */; +val* var10 /* : OptionBool */; +val* var12 /* : OptionBool */; +val* var13 /* : nullable Object */; +val* var15 /* : nullable Object */; +short int var16 /* : Bool */; +short int var17 /* : Bool */; +val* var18 /* : NativeArray[String] */; +static val* varonce; +static val* varonce19; +val* var20 /* : String */; +char* var21 /* : NativeString */; +val* var22 /* : FlatString */; +static val* varonce23; +val* var24 /* : String */; +char* var25 /* : NativeString */; +val* var26 /* : FlatString */; +val* var27 /* : String */; +static val* varonce28; +val* var29 /* : String */; +char* var30 /* : NativeString */; +val* var31 /* : FlatString */; +static val* varonce32; +val* var33 /* : String */; +char* var34 /* : NativeString */; +val* var35 /* : FlatString */; +val* var37 /* : NativeArray[String] */; +static val* varonce36; +static val* varonce38; +val* var39 /* : String */; +char* var40 /* : NativeString */; +val* var41 /* : FlatString */; +static val* varonce42; +val* var43 /* : String */; +char* var44 /* : NativeString */; +val* var45 /* : FlatString */; +val* var46 /* : String */; +val* var48 /* : NativeArray[String] */; +static val* varonce47; static val* varonce49; val* var50 /* : String */; char* var51 /* : NativeString */; -long var52 /* : Int */; -val* var53 /* : FlatString */; -static val* varonce54; -val* var55 /* : String */; -char* var56 /* : NativeString */; -long var57 /* : Int */; -val* var58 /* : FlatString */; -val* var59 /* : Array[Object] */; -long var60 /* : Int */; -val* var61 /* : NativeArray[Object] */; -val* var62 /* : Object */; -val* var63 /* : Object */; -val* var64 /* : String */; -static val* varonce65; -val* var66 /* : String */; -char* var67 /* : NativeString */; -long var68 /* : Int */; -val* var69 /* : FlatString */; -static val* varonce70; -val* var71 /* : String */; -char* var72 /* : NativeString */; -long var73 /* : Int */; -val* var74 /* : FlatString */; -long var75 /* : Int */; -long var76 /* : Int */; -val* var77 /* : Map[MClassType, Array[nullable MType]] */; -val* var79 /* : Map[MClassType, Array[nullable MType]] */; -val* var_80 /* var : Map[MClassType, Array[nullable MType]] */; -val* var81 /* : MapIterator[nullable Object, nullable Object] */; -val* var_82 /* var : MapIterator[MClassType, Array[nullable MType]] */; -short int var83 /* : Bool */; -val* var84 /* : nullable Object */; -val* var_t85 /* var t: MClassType */; -val* var86 /* : nullable Object */; -val* var_table87 /* var table: Array[nullable MType] */; -long var88 /* : Int */; -long var90 /* : Int */; -long var91 /* : Int */; -short int var93 /* : Bool */; -int cltype94; -int idtype95; -const char* var_class_name96; -long var97 /* : Int */; -val* var_98 /* var : Array[nullable MType] */; -val* var99 /* : ArrayIterator[nullable Object] */; -val* var_100 /* var : ArrayIterator[nullable MType] */; -short int var101 /* : Bool */; -val* var102 /* : nullable Object */; -val* var_e103 /* var e: nullable MType */; -val* var104 /* : null */; -short int var105 /* : Bool */; -short int var106 /* : Bool */; -short int var108 /* : Bool */; -short int var110 /* : Bool */; -long var111 /* : Int */; -long var112 /* : Int */; -short int var114 /* : Bool */; -int cltype115; -int idtype116; -const char* var_class_name117; -long var118 /* : Int */; -static val* varonce123; -val* var124 /* : String */; -char* var125 /* : NativeString */; -long var126 /* : Int */; -val* var127 /* : FlatString */; -static val* varonce128; -val* var129 /* : String */; -char* var130 /* : NativeString */; -long var131 /* : Int */; -val* var132 /* : FlatString */; -val* var133 /* : Array[Object] */; -long var134 /* : Int */; -val* var135 /* : NativeArray[Object] */; -val* var136 /* : Object */; -val* var137 /* : Object */; -val* var138 /* : String */; -static val* varonce139; -val* var140 /* : String */; -char* var141 /* : NativeString */; -long var142 /* : Int */; -val* var143 /* : FlatString */; -static val* varonce144; -val* var145 /* : String */; -char* var146 /* : NativeString */; -long var147 /* : Int */; -val* var148 /* : FlatString */; -long var149 /* : Int */; -long var150 /* : Int */; -val* var151 /* : Map[MClass, Array[nullable MPropDef]] */; -val* var153 /* : Map[MClass, Array[nullable MPropDef]] */; -val* var_154 /* var : Map[MClass, Array[nullable MPropDef]] */; -val* var155 /* : MapIterator[nullable Object, nullable Object] */; -val* var_156 /* var : MapIterator[MClass, Array[nullable MPropDef]] */; -short int var157 /* : Bool */; -val* var158 /* : nullable Object */; -val* var_t159 /* var t: MClass */; -val* var160 /* : nullable Object */; -val* var_table161 /* var table: Array[nullable MPropDef] */; -long var162 /* : Int */; -long var164 /* : Int */; -long var165 /* : Int */; -short int var167 /* : Bool */; -int cltype168; -int idtype169; -const char* var_class_name170; -long var171 /* : Int */; -val* var_172 /* var : Array[nullable MPropDef] */; -val* var173 /* : ArrayIterator[nullable Object] */; -val* var_174 /* var : ArrayIterator[nullable MPropDef] */; -short int var175 /* : Bool */; -val* var176 /* : nullable Object */; -val* var_e177 /* var e: nullable MPropDef */; -val* var178 /* : null */; -short int var179 /* : Bool */; -short int var180 /* : Bool */; -short int var182 /* : Bool */; -short int var184 /* : Bool */; -long var185 /* : Int */; -long var186 /* : Int */; -short int var188 /* : Bool */; -int cltype189; -int idtype190; -const char* var_class_name191; -long var192 /* : Int */; -static val* varonce197; -val* var198 /* : String */; -char* var199 /* : NativeString */; -long var200 /* : Int */; -val* var201 /* : FlatString */; -static val* varonce202; -val* var203 /* : String */; -char* var204 /* : NativeString */; -long var205 /* : Int */; -val* var206 /* : FlatString */; -val* var207 /* : Array[Object] */; -long var208 /* : Int */; -val* var209 /* : NativeArray[Object] */; -val* var210 /* : Object */; -val* var211 /* : Object */; -val* var212 /* : String */; -static val* varonce213; -val* var214 /* : String */; -char* var215 /* : NativeString */; -long var216 /* : Int */; -val* var217 /* : FlatString */; -static val* varonce218; -val* var219 /* : String */; -char* var220 /* : NativeString */; -long var221 /* : Int */; -val* var222 /* : FlatString */; -long var223 /* : Int */; -long var224 /* : Int */; -val* var225 /* : Map[MClass, Array[nullable MPropDef]] */; -val* var227 /* : Map[MClass, Array[nullable MPropDef]] */; -val* var_228 /* var : Map[MClass, Array[nullable MPropDef]] */; -val* var229 /* : MapIterator[nullable Object, nullable Object] */; -val* var_230 /* var : MapIterator[MClass, Array[nullable MPropDef]] */; -short int var231 /* : Bool */; -val* var232 /* : nullable Object */; -val* var_t233 /* var t: MClass */; -val* var234 /* : nullable Object */; -val* var_table235 /* var table: Array[nullable MPropDef] */; -long var236 /* : Int */; -long var238 /* : Int */; -long var239 /* : Int */; -short int var241 /* : Bool */; -int cltype242; -int idtype243; -const char* var_class_name244; -long var245 /* : Int */; -val* var_246 /* var : Array[nullable MPropDef] */; -val* var247 /* : ArrayIterator[nullable Object] */; -val* var_248 /* var : ArrayIterator[nullable MPropDef] */; -short int var249 /* : Bool */; -val* var250 /* : nullable Object */; -val* var_e251 /* var e: nullable MPropDef */; -val* var252 /* : null */; -short int var253 /* : Bool */; -short int var254 /* : Bool */; -short int var256 /* : Bool */; -short int var258 /* : Bool */; -long var259 /* : Int */; -long var260 /* : Int */; -short int var262 /* : Bool */; -int cltype263; -int idtype264; -const char* var_class_name265; -long var266 /* : Int */; -static val* varonce271; -val* var272 /* : String */; -char* var273 /* : NativeString */; -long var274 /* : Int */; -val* var275 /* : FlatString */; -static val* varonce276; -val* var277 /* : String */; -char* var278 /* : NativeString */; -long var279 /* : Int */; -val* var280 /* : FlatString */; -val* var281 /* : Array[Object] */; -long var282 /* : Int */; -val* var283 /* : NativeArray[Object] */; -val* var284 /* : Object */; -val* var285 /* : Object */; -val* var286 /* : String */; -if (varonce) { -var = varonce; -} else { -var1 = "# size of subtyping tables"; -var2 = 26; -var3 = standard___standard__NativeString___to_s_with_length(var1, var2); -var = var3; -varonce = var; -} -{ -standard__file___Object___print(self, var); /* Direct call file#Object#print on */ -} -if (varonce4) { -var5 = varonce4; -} else { -var6 = "\11total \11holes"; -var7 = 13; -var8 = standard___standard__NativeString___to_s_with_length(var6, var7); -var5 = var8; -varonce4 = var5; -} -{ -standard__file___Object___print(self, var5); /* Direct call file#Object#print on */ -} -var9 = 0; -var_total = var9; -var10 = 0; -var_holes = var10; +val* var52 /* : FlatString */; +static val* varonce53; +val* var54 /* : String */; +char* var55 /* : NativeString */; +val* var56 /* : FlatString */; +val* var57 /* : String */; +static val* varonce58; +val* var59 /* : String */; +char* var60 /* : NativeString */; +val* var61 /* : FlatString */; +static val* varonce62; +val* var63 /* : String */; +char* var64 /* : NativeString */; +val* var65 /* : FlatString */; +/* Covariant cast for argument 0 (v) isa VISITOR */ +/* isa VISITOR */ +type_struct = self->type->resolution_table->types[COLOR_nit__abstract_compiler__AbstractCompiler__VISITOR]; +cltype = type_struct->color; +idtype = type_struct->id; +if(cltype >= p0->type->table_size) { +var = 0; +} else { +var = p0->type->type_table[cltype] == idtype; +} +if (unlikely(!var)) { +var_class_name = p0 == NULL ? "null" : p0->type->name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "VISITOR", var_class_name); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 1034); +fatal_exit(1); +} +var_v = p0; +var_t = p1; { -{ /* Inline separate_compiler#SeparateCompiler#type_tables (self) on */ -var13 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___type_tables].val; /* _type_tables on */ -if (unlikely(var13 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _type_tables"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 854); -show_backtrace(1); +{ /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (var_v) on */ +var3 = var_v->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ +if (unlikely(var3 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1102); +fatal_exit(1); } -var11 = var13; -RET_LABEL12:(void)0; +var1 = var3; +RET_LABEL2:(void)0; } } -var_ = var11; { -var14 = ((val* (*)(val* self))(var_->class->vft[COLOR_standard__abstract_collection__MapRead__iterator]))(var_) /* iterator on */; +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (var1) on */ +var6 = var1->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var6 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 522); +fatal_exit(1); } -var_15 = var14; -for(;;) { -{ -var16 = ((short int (*)(val* self))(var_15->class->vft[COLOR_standard__abstract_collection__MapIterator__is_ok]))(var_15) /* is_ok on */; +var4 = var6; +RET_LABEL5:(void)0; } -if (var16){ -{ -var17 = ((val* (*)(val* self))(var_15->class->vft[COLOR_standard__abstract_collection__MapIterator__key]))(var_15) /* key on */; } -var_t = var17; { -var18 = ((val* (*)(val* self))(var_15->class->vft[COLOR_standard__abstract_collection__MapIterator__item]))(var_15) /* item on */; +{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var4) on */ +var9 = var4->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ +if (unlikely(var9 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47); +fatal_exit(1); +} +var7 = var9; +RET_LABEL8:(void)0; +} } -var_table = var18; { -{ /* Inline array#AbstractArrayRead#length (var_table) on */ -var21 = var_table->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ -var19 = var21; -RET_LABEL20:(void)0; +{ /* Inline abstract_compiler#ToolContext#opt_hardening (var7) on */ +var12 = var7->attrs[COLOR_nit__abstract_compiler__ToolContext___opt_hardening].val; /* _opt_hardening on */ +if (unlikely(var12 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_hardening"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 46); +fatal_exit(1); +} +var10 = var12; +RET_LABEL11:(void)0; } } { -{ /* Inline kernel#Int#+ (var_total,var19) on */ -/* Covariant cast for argument 0 (i) isa OTHER */ -/* isa OTHER */ -var24 = 1; /* easy isa OTHER*/ -if (unlikely(!var24)) { -var_class_name = type_standard__Int.name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); -PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413); -show_backtrace(1); +{ /* Inline opts#Option#value (var10) on */ +var15 = var10->attrs[COLOR_opts__Option___value].val; /* _value on */ +var13 = var15; +RET_LABEL14:(void)0; +} +} +var16 = (short int)((long)(var13)>>2); +var17 = !var16; +if (var17){ +goto RET_LABEL; +} else { } -var25 = var_total + var19; -var22 = var25; -goto RET_LABEL23; -RET_LABEL23:(void)0; +if (unlikely(varonce==NULL)) { +var18 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce19!=NULL)) { +var20 = varonce19; +} else { +var21 = "if("; +var22 = standard___standard__NativeString___to_s_with_length(var21, 3l); +var20 = var22; +varonce19 = var20; } +((struct instance_standard__NativeArray*)var18)->values[0]=var20; +if (likely(varonce23!=NULL)) { +var24 = varonce23; +} else { +var25 = " == NULL) {"; +var26 = standard___standard__NativeString___to_s_with_length(var25, 11l); +var24 = var26; +varonce23 = var24; } -var_total = var22; -var_26 = var_table; -{ -var27 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_26); +((struct instance_standard__NativeArray*)var18)->values[2]=var24; +} else { +var18 = varonce; +varonce = NULL; } -var_28 = var27; -for(;;) { +((struct instance_standard__NativeArray*)var18)->values[1]=var_t; { -var29 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_28); +var27 = ((val*(*)(val* self))(var18->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var18); /* native_to_s on */ } -if (var29){ +varonce = var18; { -var30 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_28); +nit___nit__AbstractCompilerVisitor___add(var_v, var27); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -var_e = var30; -var31 = NULL; -if (var_e == NULL) { -var32 = 1; /* is null */ +if (likely(varonce28!=NULL)) { +var29 = varonce28; } else { -var32 = 0; /* arg is null but recv is not */ +var30 = "type null"; +var31 = standard___standard__NativeString___to_s_with_length(var30, 9l); +var29 = var31; +varonce28 = var29; } -if (0) { -{ /* Inline kernel#Object#== (var_e,var31) on */ -var_other = var31; { -{ /* Inline kernel#Object#is_same_instance (var_e,var_other) on */ -var37 = var_e == var_other; -var35 = var37; -goto RET_LABEL36; -RET_LABEL36:(void)0; -} +nit___nit__AbstractCompilerVisitor___add_abort(var_v, var29); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_abort on */ } +if (likely(varonce32!=NULL)) { +var33 = varonce32; +} else { +var34 = "}"; +var35 = standard___standard__NativeString___to_s_with_length(var34, 1l); var33 = var35; -goto RET_LABEL34; -RET_LABEL34:(void)0; -} -var32 = var33; +varonce32 = var33; } -if (var32){ -var38 = 1; { -{ /* Inline kernel#Int#+ (var_holes,var38) on */ -/* Covariant cast for argument 0 (i) isa OTHER */ -/* isa OTHER */ -var41 = 1; /* easy isa OTHER*/ -if (unlikely(!var41)) { -var_class_name44 = type_standard__Int.name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name44); -PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413); -show_backtrace(1); +nit___nit__AbstractCompilerVisitor___add(var_v, var33); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -var45 = var_holes + var38; -var39 = var45; -goto RET_LABEL40; -RET_LABEL40:(void)0; -} -} -var_holes = var39; +if (unlikely(varonce36==NULL)) { +var37 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce38!=NULL)) { +var39 = varonce38; } else { +var40 = "if("; +var41 = standard___standard__NativeString___to_s_with_length(var40, 3l); +var39 = var41; +varonce38 = var39; } -{ -standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_28); /* Direct call array#ArrayIterator#next on */ -} +((struct instance_standard__NativeArray*)var37)->values[0]=var39; +if (likely(varonce42!=NULL)) { +var43 = varonce42; } else { -goto BREAK_label; +var44 = "->table_size < 0) {"; +var45 = standard___standard__NativeString___to_s_with_length(var44, 19l); +var43 = var45; +varonce42 = var43; } +((struct instance_standard__NativeArray*)var37)->values[2]=var43; +} else { +var37 = varonce36; +varonce36 = NULL; } -BREAK_label: (void)0; +((struct instance_standard__NativeArray*)var37)->values[1]=var_t; { -{ /* Inline abstract_collection#Iterator#finish (var_28) on */ -RET_LABEL46:(void)0; -} +var46 = ((val*(*)(val* self))(var37->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var37); /* native_to_s on */ } +varonce36 = var37; { -((void (*)(val* self))(var_15->class->vft[COLOR_standard__abstract_collection__MapIterator__next]))(var_15) /* next on */; +nit___nit__AbstractCompilerVisitor___add(var_v, var46); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (unlikely(varonce47==NULL)) { +var48 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce49!=NULL)) { +var50 = varonce49; +} else { +var51 = "PRINT_ERROR(\"Insantiation of a dead type: %s\\n\", "; +var52 = standard___standard__NativeString___to_s_with_length(var51, 49l); +var50 = var52; +varonce49 = var50; } +((struct instance_standard__NativeArray*)var48)->values[0]=var50; +if (likely(varonce53!=NULL)) { +var54 = varonce53; } else { -goto BREAK_label47; +var55 = "->name);"; +var56 = standard___standard__NativeString___to_s_with_length(var55, 8l); +var54 = var56; +varonce53 = var54; } +((struct instance_standard__NativeArray*)var48)->values[2]=var54; +} else { +var48 = varonce47; +varonce47 = NULL; } -BREAK_label47: (void)0; +((struct instance_standard__NativeArray*)var48)->values[1]=var_t; { -{ /* Inline abstract_collection#MapIterator#finish (var_15) on */ -RET_LABEL48:(void)0; +var57 = ((val*(*)(val* self))(var48->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var48); /* native_to_s on */ } +varonce47 = var48; +{ +nit___nit__AbstractCompilerVisitor___add(var_v, var57); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce49) { -var50 = varonce49; +if (likely(varonce58!=NULL)) { +var59 = varonce58; } else { -var51 = "\11"; -var52 = 1; -var53 = standard___standard__NativeString___to_s_with_length(var51, var52); -var50 = var53; -varonce49 = var50; +var60 = "type dead"; +var61 = standard___standard__NativeString___to_s_with_length(var60, 9l); +var59 = var61; +varonce58 = var59; } -if (varonce54) { -var55 = varonce54; +{ +nit___nit__AbstractCompilerVisitor___add_abort(var_v, var59); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_abort on */ +} +if (likely(varonce62!=NULL)) { +var63 = varonce62; } else { -var56 = "\11"; -var57 = 1; -var58 = standard___standard__NativeString___to_s_with_length(var56, var57); -var55 = var58; -varonce54 = var55; +var64 = "}"; +var65 = standard___standard__NativeString___to_s_with_length(var64, 1l); +var63 = var65; +varonce62 = var63; } -var59 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var59 = array_instance Array[Object] */ -var60 = 4; -var61 = NEW_standard__NativeArray(var60, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var61)->values[0] = (val*) var50; -var62 = BOX_standard__Int(var_total); /* autobox from Int to Object */ -((struct instance_standard__NativeArray*)var61)->values[1] = (val*) var62; -((struct instance_standard__NativeArray*)var61)->values[2] = (val*) var55; -var63 = BOX_standard__Int(var_holes); /* autobox from Int to Object */ -((struct instance_standard__NativeArray*)var61)->values[3] = (val*) var63; { -((void (*)(val* self, val* p0, long p1))(var59->class->vft[COLOR_standard__array__Array__with_native]))(var59, var61, var60) /* with_native on */; +nit___nit__AbstractCompilerVisitor___add(var_v, var63); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } +RET_LABEL:; } +/* method separate_compiler#SeparateCompiler#new_visitor for (self: SeparateCompiler): SeparateCompilerVisitor */ +val* nit___nit__SeparateCompiler___nit__abstract_compiler__AbstractCompiler__new_visitor(val* self) { +val* var /* : SeparateCompilerVisitor */; +val* var1 /* : SeparateCompilerVisitor */; +short int var2 /* : Bool */; +int cltype; +int idtype; +const struct type* type_struct; +const char* var_class_name; +var1 = NEW_nit__SeparateCompilerVisitor(&type_nit__SeparateCompilerVisitor); { -var64 = ((val* (*)(val* self))(var59->class->vft[COLOR_standard__string__Object__to_s]))(var59) /* to_s on */; +((void(*)(val* self, val* p0))(var1->class->vft[COLOR_nit__abstract_compiler__AbstractCompilerVisitor__compiler_61d]))(var1, self); /* compiler= on */ } { -standard__file___Object___print(self, var64); /* Direct call file#Object#print on */ +((void(*)(val* self))(var1->class->vft[COLOR_standard__kernel__Object__init]))(var1); /* init on */ } -if (varonce65) { -var66 = varonce65; +/* isa VISITOR */ +type_struct = self->type->resolution_table->types[COLOR_nit__abstract_compiler__AbstractCompiler__VISITOR]; +cltype = type_struct->color; +idtype = type_struct->id; +if(cltype >= var1->type->table_size) { +var2 = 0; } else { -var67 = "# size of resolution tables"; -var68 = 27; -var69 = standard___standard__NativeString___to_s_with_length(var67, var68); -var66 = var69; -varonce65 = var66; +var2 = var1->type->type_table[cltype] == idtype; } -{ -standard__file___Object___print(self, var66); /* Direct call file#Object#print on */ +if (unlikely(!var2)) { +var_class_name = var1 == NULL ? "null" : var1->type->name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "VISITOR", var_class_name); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 1047); +fatal_exit(1); } -if (varonce70) { -var71 = varonce70; -} else { -var72 = "\11total \11holes"; -var73 = 13; -var74 = standard___standard__NativeString___to_s_with_length(var72, var73); -var71 = var74; -varonce70 = var71; +var = var1; +goto RET_LABEL; +RET_LABEL:; +return var; } -{ -standard__file___Object___print(self, var71); /* Direct call file#Object#print on */ +/* method separate_compiler#SeparateCompiler#type_tables for (self: SeparateCompiler): Map[MType, Array[nullable MType]] */ +val* nit___nit__SeparateCompiler___type_tables(val* self) { +val* var /* : Map[MType, Array[nullable MType]] */; +val* var1 /* : Map[MType, Array[nullable MType]] */; +var1 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___type_tables].val; /* _type_tables on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _type_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 1051); +fatal_exit(1); } -var75 = 0; -var_total = var75; -var76 = 0; -var_holes = var76; -{ -{ /* Inline separate_compiler#SeparateCompiler#resolution_tables (self) on */ -var79 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___resolution_tables].val; /* _resolution_tables on */ -if (unlikely(var79 == NULL)) { +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#type_tables= for (self: SeparateCompiler, Map[MType, Array[nullable MType]]) */ +void nit___nit__SeparateCompiler___type_tables_61d(val* self, val* p0) { +self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___type_tables].val = p0; /* _type_tables on */ +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#resolution_tables for (self: SeparateCompiler): Map[MClassType, Array[nullable MType]] */ +val* nit___nit__SeparateCompiler___resolution_tables(val* self) { +val* var /* : Map[MClassType, Array[nullable MType]] */; +val* var1 /* : Map[MClassType, Array[nullable MType]] */; +var1 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___resolution_tables].val; /* _resolution_tables on */ +if (unlikely(var1 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _resolution_tables"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 855); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 1052); +fatal_exit(1); } -var77 = var79; -RET_LABEL78:(void)0; +var = var1; +RET_LABEL:; +return var; } +/* method separate_compiler#SeparateCompiler#resolution_tables= for (self: SeparateCompiler, Map[MClassType, Array[nullable MType]]) */ +void nit___nit__SeparateCompiler___resolution_tables_61d(val* self, val* p0) { +self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___resolution_tables].val = p0; /* _resolution_tables on */ +RET_LABEL:; } -var_80 = var77; -{ -var81 = ((val* (*)(val* self))(var_80->class->vft[COLOR_standard__abstract_collection__MapRead__iterator]))(var_80) /* iterator on */; +/* method separate_compiler#SeparateCompiler#method_tables for (self: SeparateCompiler): Map[MClass, Array[nullable MPropDef]] */ +val* nit___nit__SeparateCompiler___method_tables(val* self) { +val* var /* : Map[MClass, Array[nullable MPropDef]] */; +val* var1 /* : Map[MClass, Array[nullable MPropDef]] */; +var1 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___method_tables].val; /* _method_tables on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _method_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 1053); +fatal_exit(1); } -var_82 = var81; -for(;;) { -{ -var83 = ((short int (*)(val* self))(var_82->class->vft[COLOR_standard__abstract_collection__MapIterator__is_ok]))(var_82) /* is_ok on */; +var = var1; +RET_LABEL:; +return var; } -if (var83){ -{ -var84 = ((val* (*)(val* self))(var_82->class->vft[COLOR_standard__abstract_collection__MapIterator__key]))(var_82) /* key on */; +/* method separate_compiler#SeparateCompiler#method_tables= for (self: SeparateCompiler, Map[MClass, Array[nullable MPropDef]]) */ +void nit___nit__SeparateCompiler___method_tables_61d(val* self, val* p0) { +self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___method_tables].val = p0; /* _method_tables on */ +RET_LABEL:; } -var_t85 = var84; -{ -var86 = ((val* (*)(val* self))(var_82->class->vft[COLOR_standard__abstract_collection__MapIterator__item]))(var_82) /* item on */; +/* method separate_compiler#SeparateCompiler#attr_tables for (self: SeparateCompiler): Map[MClass, Array[nullable MProperty]] */ +val* nit___nit__SeparateCompiler___attr_tables(val* self) { +val* var /* : Map[MClass, Array[nullable MProperty]] */; +val* var1 /* : Map[MClass, Array[nullable MProperty]] */; +var1 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___attr_tables].val; /* _attr_tables on */ +if (unlikely(var1 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _attr_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 1054); +fatal_exit(1); } -var_table87 = var86; -{ -{ /* Inline array#AbstractArrayRead#length (var_table87) on */ -var90 = var_table87->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ -var88 = var90; -RET_LABEL89:(void)0; +var = var1; +RET_LABEL:; +return var; } +/* method separate_compiler#SeparateCompiler#attr_tables= for (self: SeparateCompiler, Map[MClass, Array[nullable MProperty]]) */ +void nit___nit__SeparateCompiler___attr_tables_61d(val* self, val* p0) { +self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___attr_tables].val = p0; /* _attr_tables on */ +RET_LABEL:; } +/* method separate_compiler#SeparateCompiler#display_stats for (self: SeparateCompiler) */ +void nit___nit__SeparateCompiler___nit__abstract_compiler__AbstractCompiler__display_stats(val* self) { +val* var /* : ModelBuilder */; +val* var2 /* : ModelBuilder */; +val* var3 /* : ToolContext */; +val* var5 /* : ToolContext */; +val* var6 /* : OptionBool */; +val* var8 /* : OptionBool */; +val* var9 /* : nullable Object */; +val* var11 /* : nullable Object */; +short int var12 /* : Bool */; +val* var13 /* : ModelBuilder */; +val* var15 /* : ModelBuilder */; +val* var16 /* : ToolContext */; +val* var18 /* : ToolContext */; +val* var19 /* : OptionBool */; +val* var21 /* : OptionBool */; +val* var22 /* : nullable Object */; +val* var24 /* : nullable Object */; +short int var25 /* : Bool */; +val* var26 /* : ModelBuilder */; +val* var28 /* : ModelBuilder */; +val* var29 /* : ToolContext */; +val* var31 /* : ToolContext */; +val* var_tc /* var tc: ToolContext */; +static val* varonce; +val* var32 /* : String */; +char* var33 /* : NativeString */; +val* var34 /* : FlatString */; +val* var35 /* : ModelBuilder */; +val* var37 /* : ModelBuilder */; +long var38 /* : Int */; +long var40 /* : Int */; +val* var41 /* : ModelBuilder */; +val* var43 /* : ModelBuilder */; +long var44 /* : Int */; +long var46 /* : Int */; +long var47 /* : Int */; +short int var49 /* : Bool */; +int cltype; +int idtype; +const char* var_class_name; +long var50 /* : Int */; +val* var51 /* : ModelBuilder */; +val* var53 /* : ModelBuilder */; +long var54 /* : Int */; +long var56 /* : Int */; +long var57 /* : Int */; +short int var59 /* : Bool */; +int cltype60; +int idtype61; +const char* var_class_name62; +long var63 /* : Int */; +long var_nb_invok_total /* var nb_invok_total: Int */; +val* var65 /* : NativeArray[String] */; +static val* varonce64; +static val* varonce66; +val* var67 /* : String */; +char* var68 /* : NativeString */; +val* var69 /* : FlatString */; +val* var70 /* : String */; +val* var71 /* : String */; +val* var73 /* : NativeArray[String] */; +static val* varonce72; +static val* varonce74; +val* var75 /* : String */; +char* var76 /* : NativeString */; +val* var77 /* : FlatString */; +static val* varonce78; +val* var79 /* : String */; +char* var80 /* : NativeString */; +val* var81 /* : FlatString */; +static val* varonce82; +val* var83 /* : String */; +char* var84 /* : NativeString */; +val* var85 /* : FlatString */; +val* var86 /* : ModelBuilder */; +val* var88 /* : ModelBuilder */; +long var89 /* : Int */; +long var91 /* : Int */; +val* var92 /* : String */; +val* var93 /* : Sys */; +val* var94 /* : ModelBuilder */; +val* var96 /* : ModelBuilder */; +long var97 /* : Int */; +long var99 /* : Int */; +val* var100 /* : String */; +val* var101 /* : String */; +val* var103 /* : NativeArray[String] */; +static val* varonce102; +static val* varonce104; +val* var105 /* : String */; +char* var106 /* : NativeString */; +val* var107 /* : FlatString */; +static val* varonce108; +val* var109 /* : String */; +char* var110 /* : NativeString */; +val* var111 /* : FlatString */; +static val* varonce112; +val* var113 /* : String */; +char* var114 /* : NativeString */; +val* var115 /* : FlatString */; +val* var116 /* : ModelBuilder */; +val* var118 /* : ModelBuilder */; +long var119 /* : Int */; +long var121 /* : Int */; +val* var122 /* : String */; +val* var123 /* : Sys */; +val* var124 /* : ModelBuilder */; +val* var126 /* : ModelBuilder */; +long var127 /* : Int */; +long var129 /* : Int */; +val* var130 /* : String */; +val* var131 /* : String */; +val* var133 /* : NativeArray[String] */; +static val* varonce132; +static val* varonce134; +val* var135 /* : String */; +char* var136 /* : NativeString */; +val* var137 /* : FlatString */; +static val* varonce138; +val* var139 /* : String */; +char* var140 /* : NativeString */; +val* var141 /* : FlatString */; +static val* varonce142; +val* var143 /* : String */; +char* var144 /* : NativeString */; +val* var145 /* : FlatString */; +val* var146 /* : ModelBuilder */; +val* var148 /* : ModelBuilder */; +long var149 /* : Int */; +long var151 /* : Int */; +val* var152 /* : String */; +val* var153 /* : Sys */; +val* var154 /* : ModelBuilder */; +val* var156 /* : ModelBuilder */; +long var157 /* : Int */; +long var159 /* : Int */; +val* var160 /* : String */; +val* var161 /* : String */; { -{ /* Inline kernel#Int#+ (var_total,var88) on */ -/* Covariant cast for argument 0 (i) isa OTHER */ -/* isa OTHER */ -var93 = 1; /* easy isa OTHER*/ -if (unlikely(!var93)) { -var_class_name96 = type_standard__Int.name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name96); -PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413); -show_backtrace(1); +((void(*)(val* self))(self->class->vft[COLOR_nit___nit__SeparateCompiler___nit__abstract_compiler__AbstractCompiler__display_stats]))(self); /* display_stats on */ } -var97 = var_total + var88; -var91 = var97; -goto RET_LABEL92; -RET_LABEL92:(void)0; +{ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var2 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 522); +fatal_exit(1); } +var = var2; +RET_LABEL1:(void)0; } -var_total = var91; -var_98 = var_table87; -{ -var99 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_98); } -var_100 = var99; -for(;;) { { -var101 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_100); +{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var) on */ +var5 = var->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ +if (unlikely(var5 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47); +fatal_exit(1); } -if (var101){ -{ -var102 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_100); +var3 = var5; +RET_LABEL4:(void)0; } -var_e103 = var102; -var104 = NULL; -if (var_e103 == NULL) { -var105 = 1; /* is null */ -} else { -var105 = 0; /* arg is null but recv is not */ } -if (0) { -{ /* Inline kernel#Object#== (var_e103,var104) on */ -var_other = var104; { -{ /* Inline kernel#Object#is_same_instance (var_e103,var_other) on */ -var110 = var_e103 == var_other; -var108 = var110; -goto RET_LABEL109; -RET_LABEL109:(void)0; -} +{ /* Inline separate_compiler#ToolContext#opt_tables_metrics (var3) on */ +var8 = var3->attrs[COLOR_nit__separate_compiler__ToolContext___opt_tables_metrics].val; /* _opt_tables_metrics on */ +if (unlikely(var8 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_tables_metrics"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 60); +fatal_exit(1); } -var106 = var108; -goto RET_LABEL107; -RET_LABEL107:(void)0; +var6 = var8; +RET_LABEL7:(void)0; } -var105 = var106; } -if (var105){ -var111 = 1; { -{ /* Inline kernel#Int#+ (var_holes,var111) on */ -/* Covariant cast for argument 0 (i) isa OTHER */ -/* isa OTHER */ -var114 = 1; /* easy isa OTHER*/ -if (unlikely(!var114)) { -var_class_name117 = type_standard__Int.name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name117); -PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413); -show_backtrace(1); +{ /* Inline opts#Option#value (var6) on */ +var11 = var6->attrs[COLOR_opts__Option___value].val; /* _value on */ +var9 = var11; +RET_LABEL10:(void)0; } -var118 = var_holes + var111; -var112 = var118; -goto RET_LABEL113; -RET_LABEL113:(void)0; } +var12 = (short int)((long)(var9)>>2); +if (var12){ +{ +((void(*)(val* self))(self->class->vft[COLOR_nit__separate_compiler__SeparateCompiler__display_sizes]))(self); /* display_sizes on */ } -var_holes = var112; } else { } { -standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_100); /* Direct call array#ArrayIterator#next on */ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var15 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var15 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 522); +fatal_exit(1); } -} else { -goto BREAK_label119; +var13 = var15; +RET_LABEL14:(void)0; } } -BREAK_label119: (void)0; { -{ /* Inline abstract_collection#Iterator#finish (var_100) on */ -RET_LABEL120:(void)0; +{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var13) on */ +var18 = var13->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ +if (unlikely(var18 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47); +fatal_exit(1); +} +var16 = var18; +RET_LABEL17:(void)0; } } { -((void (*)(val* self))(var_82->class->vft[COLOR_standard__abstract_collection__MapIterator__next]))(var_82) /* next on */; +{ /* Inline abstract_compiler#ToolContext#opt_isset_checks_metrics (var16) on */ +var21 = var16->attrs[COLOR_nit__abstract_compiler__ToolContext___opt_isset_checks_metrics].val; /* _opt_isset_checks_metrics on */ +if (unlikely(var21 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_isset_checks_metrics"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 64); +fatal_exit(1); } -} else { -goto BREAK_label121; +var19 = var21; +RET_LABEL20:(void)0; } } -BREAK_label121: (void)0; { -{ /* Inline abstract_collection#MapIterator#finish (var_82) on */ -RET_LABEL122:(void)0; +{ /* Inline opts#Option#value (var19) on */ +var24 = var19->attrs[COLOR_opts__Option___value].val; /* _value on */ +var22 = var24; +RET_LABEL23:(void)0; } } -if (varonce123) { -var124 = varonce123; -} else { -var125 = "\11"; -var126 = 1; -var127 = standard___standard__NativeString___to_s_with_length(var125, var126); -var124 = var127; -varonce123 = var124; +var25 = (short int)((long)(var22)>>2); +if (var25){ +{ +nit___nit__SeparateCompiler___display_isset_checks(self); /* Direct call separate_compiler#SeparateCompiler#display_isset_checks on */ } -if (varonce128) { -var129 = varonce128; } else { -var130 = "\11"; -var131 = 1; -var132 = standard___standard__NativeString___to_s_with_length(var130, var131); -var129 = var132; -varonce128 = var129; } -var133 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var133 = array_instance Array[Object] */ -var134 = 4; -var135 = NEW_standard__NativeArray(var134, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var135)->values[0] = (val*) var124; -var136 = BOX_standard__Int(var_total); /* autobox from Int to Object */ -((struct instance_standard__NativeArray*)var135)->values[1] = (val*) var136; -((struct instance_standard__NativeArray*)var135)->values[2] = (val*) var129; -var137 = BOX_standard__Int(var_holes); /* autobox from Int to Object */ -((struct instance_standard__NativeArray*)var135)->values[3] = (val*) var137; { -((void (*)(val* self, val* p0, long p1))(var133->class->vft[COLOR_standard__array__Array__with_native]))(var133, var135, var134) /* with_native on */; +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var28 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var28 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 522); +fatal_exit(1); } +var26 = var28; +RET_LABEL27:(void)0; } -{ -var138 = ((val* (*)(val* self))(var133->class->vft[COLOR_standard__string__Object__to_s]))(var133) /* to_s on */; } { -standard__file___Object___print(self, var138); /* Direct call file#Object#print on */ +{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var26) on */ +var31 = var26->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ +if (unlikely(var31 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47); +fatal_exit(1); } -if (varonce139) { -var140 = varonce139; -} else { -var141 = "# size of methods tables"; -var142 = 24; -var143 = standard___standard__NativeString___to_s_with_length(var141, var142); -var140 = var143; -varonce139 = var140; +var29 = var31; +RET_LABEL30:(void)0; } -{ -standard__file___Object___print(self, var140); /* Direct call file#Object#print on */ } -if (varonce144) { -var145 = varonce144; +var_tc = var29; +if (likely(varonce!=NULL)) { +var32 = varonce; } else { -var146 = "\11total \11holes"; -var147 = 13; -var148 = standard___standard__NativeString___to_s_with_length(var146, var147); -var145 = var148; -varonce144 = var145; +var33 = "# implementation of method invocation"; +var34 = standard___standard__NativeString___to_s_with_length(var33, 37l); +var32 = var34; +varonce = var32; } { -standard__file___Object___print(self, var145); /* Direct call file#Object#print on */ +nit___nit__ToolContext___info(var_tc, var32, 2l); /* Direct call toolcontext#ToolContext#info on */ } -var149 = 0; -var_total = var149; -var150 = 0; -var_holes = var150; { -{ /* Inline separate_compiler#SeparateCompiler#method_tables (self) on */ -var153 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___method_tables].val; /* _method_tables on */ -if (unlikely(var153 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _method_tables"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 856); -show_backtrace(1); +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var37 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var37 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 522); +fatal_exit(1); } -var151 = var153; -RET_LABEL152:(void)0; +var35 = var37; +RET_LABEL36:(void)0; } } -var_154 = var151; { -var155 = ((val* (*)(val* self))(var_154->class->vft[COLOR_standard__abstract_collection__MapRead__iterator]))(var_154) /* iterator on */; +{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_tables (var35) on */ +var40 = var35->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_tables].l; /* _nb_invok_by_tables on */ +var38 = var40; +RET_LABEL39:(void)0; } -var_156 = var155; -for(;;) { -{ -var157 = ((short int (*)(val* self))(var_156->class->vft[COLOR_standard__abstract_collection__MapIterator__is_ok]))(var_156) /* is_ok on */; } -if (var157){ { -var158 = ((val* (*)(val* self))(var_156->class->vft[COLOR_standard__abstract_collection__MapIterator__key]))(var_156) /* key on */; +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var43 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var43 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 522); +fatal_exit(1); +} +var41 = var43; +RET_LABEL42:(void)0; } -var_t159 = var158; -{ -var160 = ((val* (*)(val* self))(var_156->class->vft[COLOR_standard__abstract_collection__MapIterator__item]))(var_156) /* item on */; } -var_table161 = var160; { -{ /* Inline array#AbstractArrayRead#length (var_table161) on */ -var164 = var_table161->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ -var162 = var164; -RET_LABEL163:(void)0; +{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_direct (var41) on */ +var46 = var41->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_direct].l; /* _nb_invok_by_direct on */ +var44 = var46; +RET_LABEL45:(void)0; } } { -{ /* Inline kernel#Int#+ (var_total,var162) on */ -/* Covariant cast for argument 0 (i) isa OTHER */ -/* isa OTHER */ -var167 = 1; /* easy isa OTHER*/ -if (unlikely(!var167)) { -var_class_name170 = type_standard__Int.name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name170); -PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413); -show_backtrace(1); -} -var171 = var_total + var162; -var165 = var171; -goto RET_LABEL166; -RET_LABEL166:(void)0; +{ /* Inline kernel#Int#+ (var38,var44) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var49 = 1; /* easy isa OTHER*/ +if (unlikely(!var49)) { +var_class_name = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 537); +fatal_exit(1); } +var50 = var38 + var44; +var47 = var50; +goto RET_LABEL48; +RET_LABEL48:(void)0; } -var_total = var165; -var_172 = var_table161; -{ -var173 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_172); } -var_174 = var173; -for(;;) { { -var175 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_174); +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var53 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var53 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 522); +fatal_exit(1); } -if (var175){ -{ -var176 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_174); +var51 = var53; +RET_LABEL52:(void)0; } -var_e177 = var176; -var178 = NULL; -if (var_e177 == NULL) { -var179 = 1; /* is null */ -} else { -var179 = 0; /* arg is null but recv is not */ } -if (0) { -{ /* Inline kernel#Object#== (var_e177,var178) on */ -var_other = var178; { -{ /* Inline kernel#Object#is_same_instance (var_e177,var_other) on */ -var184 = var_e177 == var_other; -var182 = var184; -goto RET_LABEL183; -RET_LABEL183:(void)0; +{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_inline (var51) on */ +var56 = var51->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_inline].l; /* _nb_invok_by_inline on */ +var54 = var56; +RET_LABEL55:(void)0; } } -var180 = var182; -goto RET_LABEL181; -RET_LABEL181:(void)0; -} -var179 = var180; -} -if (var179){ -var185 = 1; { -{ /* Inline kernel#Int#+ (var_holes,var185) on */ -/* Covariant cast for argument 0 (i) isa OTHER */ -/* isa OTHER */ -var188 = 1; /* easy isa OTHER*/ -if (unlikely(!var188)) { -var_class_name191 = type_standard__Int.name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name191); -PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413); -show_backtrace(1); +{ /* Inline kernel#Int#+ (var47,var54) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var59 = 1; /* easy isa OTHER*/ +if (unlikely(!var59)) { +var_class_name62 = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name62); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 537); +fatal_exit(1); } -var192 = var_holes + var185; -var186 = var192; -goto RET_LABEL187; -RET_LABEL187:(void)0; +var63 = var47 + var54; +var57 = var63; +goto RET_LABEL58; +RET_LABEL58:(void)0; } } -var_holes = var186; +var_nb_invok_total = var57; +if (unlikely(varonce64==NULL)) { +var65 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce66!=NULL)) { +var67 = varonce66; } else { +var68 = "total number of invocations: "; +var69 = standard___standard__NativeString___to_s_with_length(var68, 29l); +var67 = var69; +varonce66 = var67; } -{ -standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_174); /* Direct call array#ArrayIterator#next on */ -} +((struct instance_standard__NativeArray*)var65)->values[0]=var67; } else { -goto BREAK_label193; -} +var65 = varonce64; +varonce64 = NULL; } -BREAK_label193: (void)0; +var70 = standard__string___Int___Object__to_s(var_nb_invok_total); +((struct instance_standard__NativeArray*)var65)->values[1]=var70; { -{ /* Inline abstract_collection#Iterator#finish (var_174) on */ -RET_LABEL194:(void)0; -} +var71 = ((val*(*)(val* self))(var65->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var65); /* native_to_s on */ } +varonce64 = var65; { -((void (*)(val* self))(var_156->class->vft[COLOR_standard__abstract_collection__MapIterator__next]))(var_156) /* next on */; +nit___nit__ToolContext___info(var_tc, var71, 2l); /* Direct call toolcontext#ToolContext#info on */ } +if (unlikely(varonce72==NULL)) { +var73 = NEW_standard__NativeArray(5l, &type_standard__NativeArray__standard__String); +if (likely(varonce74!=NULL)) { +var75 = varonce74; } else { -goto BREAK_label195; -} -} -BREAK_label195: (void)0; -{ -{ /* Inline abstract_collection#MapIterator#finish (var_156) on */ -RET_LABEL196:(void)0; +var76 = "invocations by VFT send: "; +var77 = standard___standard__NativeString___to_s_with_length(var76, 29l); +var75 = var77; +varonce74 = var75; } +((struct instance_standard__NativeArray*)var73)->values[0]=var75; +if (likely(varonce78!=NULL)) { +var79 = varonce78; +} else { +var80 = " ("; +var81 = standard___standard__NativeString___to_s_with_length(var80, 2l); +var79 = var81; +varonce78 = var79; } -if (varonce197) { -var198 = varonce197; +((struct instance_standard__NativeArray*)var73)->values[2]=var79; +if (likely(varonce82!=NULL)) { +var83 = varonce82; } else { -var199 = "\11"; -var200 = 1; -var201 = standard___standard__NativeString___to_s_with_length(var199, var200); -var198 = var201; -varonce197 = var198; +var84 = "%)"; +var85 = standard___standard__NativeString___to_s_with_length(var84, 2l); +var83 = var85; +varonce82 = var83; } -if (varonce202) { -var203 = varonce202; +((struct instance_standard__NativeArray*)var73)->values[4]=var83; } else { -var204 = "\11"; -var205 = 1; -var206 = standard___standard__NativeString___to_s_with_length(var204, var205); -var203 = var206; -varonce202 = var203; +var73 = varonce72; +varonce72 = NULL; } -var207 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var207 = array_instance Array[Object] */ -var208 = 4; -var209 = NEW_standard__NativeArray(var208, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var209)->values[0] = (val*) var198; -var210 = BOX_standard__Int(var_total); /* autobox from Int to Object */ -((struct instance_standard__NativeArray*)var209)->values[1] = (val*) var210; -((struct instance_standard__NativeArray*)var209)->values[2] = (val*) var203; -var211 = BOX_standard__Int(var_holes); /* autobox from Int to Object */ -((struct instance_standard__NativeArray*)var209)->values[3] = (val*) var211; { -((void (*)(val* self, val* p0, long p1))(var207->class->vft[COLOR_standard__array__Array__with_native]))(var207, var209, var208) /* with_native on */; +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var88 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var88 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 522); +fatal_exit(1); } +var86 = var88; +RET_LABEL87:(void)0; } -{ -var212 = ((val* (*)(val* self))(var207->class->vft[COLOR_standard__string__Object__to_s]))(var207) /* to_s on */; } { -standard__file___Object___print(self, var212); /* Direct call file#Object#print on */ +{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_tables (var86) on */ +var91 = var86->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_tables].l; /* _nb_invok_by_tables on */ +var89 = var91; +RET_LABEL90:(void)0; } -if (varonce213) { -var214 = varonce213; -} else { -var215 = "# size of attributes tables"; -var216 = 27; -var217 = standard___standard__NativeString___to_s_with_length(var215, var216); -var214 = var217; -varonce213 = var214; } +var92 = standard__string___Int___Object__to_s(var89); +((struct instance_standard__NativeArray*)var73)->values[1]=var92; +var93 = glob_sys; { -standard__file___Object___print(self, var214); /* Direct call file#Object#print on */ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var96 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var96 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 522); +fatal_exit(1); } -if (varonce218) { -var219 = varonce218; -} else { -var220 = "\11total \11holes"; -var221 = 13; -var222 = standard___standard__NativeString___to_s_with_length(var220, var221); -var219 = var222; -varonce218 = var219; +var94 = var96; +RET_LABEL95:(void)0; } -{ -standard__file___Object___print(self, var219); /* Direct call file#Object#print on */ } -var223 = 0; -var_total = var223; -var224 = 0; -var_holes = var224; { -{ /* Inline separate_compiler#SeparateCompiler#attr_tables (self) on */ -var227 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___attr_tables].val; /* _attr_tables on */ -if (unlikely(var227 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _attr_tables"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 857); -show_backtrace(1); -} -var225 = var227; -RET_LABEL226:(void)0; +{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_tables (var94) on */ +var99 = var94->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_tables].l; /* _nb_invok_by_tables on */ +var97 = var99; +RET_LABEL98:(void)0; } } -var_228 = var225; { -var229 = ((val* (*)(val* self))(var_228->class->vft[COLOR_standard__abstract_collection__MapRead__iterator]))(var_228) /* iterator on */; +var100 = counter___standard__Sys___div(var93, var97, var_nb_invok_total); } -var_230 = var229; -for(;;) { +((struct instance_standard__NativeArray*)var73)->values[3]=var100; { -var231 = ((short int (*)(val* self))(var_230->class->vft[COLOR_standard__abstract_collection__MapIterator__is_ok]))(var_230) /* is_ok on */; +var101 = ((val*(*)(val* self))(var73->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var73); /* native_to_s on */ } -if (var231){ +varonce72 = var73; { -var232 = ((val* (*)(val* self))(var_230->class->vft[COLOR_standard__abstract_collection__MapIterator__key]))(var_230) /* key on */; +nit___nit__ToolContext___info(var_tc, var101, 2l); /* Direct call toolcontext#ToolContext#info on */ } -var_t233 = var232; -{ -var234 = ((val* (*)(val* self))(var_230->class->vft[COLOR_standard__abstract_collection__MapIterator__item]))(var_230) /* item on */; +if (unlikely(varonce102==NULL)) { +var103 = NEW_standard__NativeArray(5l, &type_standard__NativeArray__standard__String); +if (likely(varonce104!=NULL)) { +var105 = varonce104; +} else { +var106 = "invocations by direct call: "; +var107 = standard___standard__NativeString___to_s_with_length(var106, 29l); +var105 = var107; +varonce104 = var105; } -var_table235 = var234; -{ -{ /* Inline array#AbstractArrayRead#length (var_table235) on */ -var238 = var_table235->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ -var236 = var238; -RET_LABEL237:(void)0; +((struct instance_standard__NativeArray*)var103)->values[0]=var105; +if (likely(varonce108!=NULL)) { +var109 = varonce108; +} else { +var110 = " ("; +var111 = standard___standard__NativeString___to_s_with_length(var110, 2l); +var109 = var111; +varonce108 = var109; +} +((struct instance_standard__NativeArray*)var103)->values[2]=var109; +if (likely(varonce112!=NULL)) { +var113 = varonce112; +} else { +var114 = "%)"; +var115 = standard___standard__NativeString___to_s_with_length(var114, 2l); +var113 = var115; +varonce112 = var113; } +((struct instance_standard__NativeArray*)var103)->values[4]=var113; +} else { +var103 = varonce102; +varonce102 = NULL; } { -{ /* Inline kernel#Int#+ (var_total,var236) on */ -/* Covariant cast for argument 0 (i) isa OTHER */ -/* isa OTHER */ -var241 = 1; /* easy isa OTHER*/ -if (unlikely(!var241)) { -var_class_name244 = type_standard__Int.name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name244); -PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413); -show_backtrace(1); +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var118 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var118 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 522); +fatal_exit(1); } -var245 = var_total + var236; -var239 = var245; -goto RET_LABEL240; -RET_LABEL240:(void)0; +var116 = var118; +RET_LABEL117:(void)0; } } -var_total = var239; -var_246 = var_table235; { -var247 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_246); +{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_direct (var116) on */ +var121 = var116->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_direct].l; /* _nb_invok_by_direct on */ +var119 = var121; +RET_LABEL120:(void)0; } -var_248 = var247; -for(;;) { -{ -var249 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_248); } -if (var249){ +var122 = standard__string___Int___Object__to_s(var119); +((struct instance_standard__NativeArray*)var103)->values[1]=var122; +var123 = glob_sys; { -var250 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_248); -} -var_e251 = var250; -var252 = NULL; -if (var_e251 == NULL) { -var253 = 1; /* is null */ -} else { -var253 = 0; /* arg is null but recv is not */ +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var126 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var126 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 522); +fatal_exit(1); } -if (0) { -{ /* Inline kernel#Object#== (var_e251,var252) on */ -var_other = var252; -{ -{ /* Inline kernel#Object#is_same_instance (var_e251,var_other) on */ -var258 = var_e251 == var_other; -var256 = var258; -goto RET_LABEL257; -RET_LABEL257:(void)0; +var124 = var126; +RET_LABEL125:(void)0; } } -var254 = var256; -goto RET_LABEL255; -RET_LABEL255:(void)0; +{ +{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_direct (var124) on */ +var129 = var124->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_direct].l; /* _nb_invok_by_direct on */ +var127 = var129; +RET_LABEL128:(void)0; } -var253 = var254; } -if (var253){ -var259 = 1; { -{ /* Inline kernel#Int#+ (var_holes,var259) on */ -/* Covariant cast for argument 0 (i) isa OTHER */ -/* isa OTHER */ -var262 = 1; /* easy isa OTHER*/ -if (unlikely(!var262)) { -var_class_name265 = type_standard__Int.name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name265); -PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413); -show_backtrace(1); +var130 = counter___standard__Sys___div(var123, var127, var_nb_invok_total); } -var266 = var_holes + var259; -var260 = var266; -goto RET_LABEL261; -RET_LABEL261:(void)0; +((struct instance_standard__NativeArray*)var103)->values[3]=var130; +{ +var131 = ((val*(*)(val* self))(var103->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var103); /* native_to_s on */ } +varonce102 = var103; +{ +nit___nit__ToolContext___info(var_tc, var131, 2l); /* Direct call toolcontext#ToolContext#info on */ } -var_holes = var260; +if (unlikely(varonce132==NULL)) { +var133 = NEW_standard__NativeArray(5l, &type_standard__NativeArray__standard__String); +if (likely(varonce134!=NULL)) { +var135 = varonce134; } else { +var136 = "invocations by inlining: "; +var137 = standard___standard__NativeString___to_s_with_length(var136, 29l); +var135 = var137; +varonce134 = var135; } -{ -standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_248); /* Direct call array#ArrayIterator#next on */ +((struct instance_standard__NativeArray*)var133)->values[0]=var135; +if (likely(varonce138!=NULL)) { +var139 = varonce138; +} else { +var140 = " ("; +var141 = standard___standard__NativeString___to_s_with_length(var140, 2l); +var139 = var141; +varonce138 = var139; } +((struct instance_standard__NativeArray*)var133)->values[2]=var139; +if (likely(varonce142!=NULL)) { +var143 = varonce142; } else { -goto BREAK_label267; +var144 = "%)"; +var145 = standard___standard__NativeString___to_s_with_length(var144, 2l); +var143 = var145; +varonce142 = var143; } +((struct instance_standard__NativeArray*)var133)->values[4]=var143; +} else { +var133 = varonce132; +varonce132 = NULL; } -BREAK_label267: (void)0; { -{ /* Inline abstract_collection#Iterator#finish (var_248) on */ -RET_LABEL268:(void)0; +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var148 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var148 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 522); +fatal_exit(1); } +var146 = var148; +RET_LABEL147:(void)0; } -{ -((void (*)(val* self))(var_230->class->vft[COLOR_standard__abstract_collection__MapIterator__next]))(var_230) /* next on */; } -} else { -goto BREAK_label269; +{ +{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_inline (var146) on */ +var151 = var146->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_inline].l; /* _nb_invok_by_inline on */ +var149 = var151; +RET_LABEL150:(void)0; } } -BREAK_label269: (void)0; +var152 = standard__string___Int___Object__to_s(var149); +((struct instance_standard__NativeArray*)var133)->values[1]=var152; +var153 = glob_sys; { -{ /* Inline abstract_collection#MapIterator#finish (var_230) on */ -RET_LABEL270:(void)0; -} +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (self) on */ +var156 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var156 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 522); +fatal_exit(1); } -if (varonce271) { -var272 = varonce271; -} else { -var273 = "\11"; -var274 = 1; -var275 = standard___standard__NativeString___to_s_with_length(var273, var274); -var272 = var275; -varonce271 = var272; +var154 = var156; +RET_LABEL155:(void)0; } -if (varonce276) { -var277 = varonce276; -} else { -var278 = "\11"; -var279 = 1; -var280 = standard___standard__NativeString___to_s_with_length(var278, var279); -var277 = var280; -varonce276 = var277; } -var281 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var281 = array_instance Array[Object] */ -var282 = 4; -var283 = NEW_standard__NativeArray(var282, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var283)->values[0] = (val*) var272; -var284 = BOX_standard__Int(var_total); /* autobox from Int to Object */ -((struct instance_standard__NativeArray*)var283)->values[1] = (val*) var284; -((struct instance_standard__NativeArray*)var283)->values[2] = (val*) var277; -var285 = BOX_standard__Int(var_holes); /* autobox from Int to Object */ -((struct instance_standard__NativeArray*)var283)->values[3] = (val*) var285; { -((void (*)(val* self, val* p0, long p1))(var281->class->vft[COLOR_standard__array__Array__with_native]))(var281, var283, var282) /* with_native on */; +{ /* Inline separate_compiler#ModelBuilder#nb_invok_by_inline (var154) on */ +var159 = var154->attrs[COLOR_nit__separate_compiler__ModelBuilder___nb_invok_by_inline].l; /* _nb_invok_by_inline on */ +var157 = var159; +RET_LABEL158:(void)0; } } { -var286 = ((val* (*)(val* self))(var281->class->vft[COLOR_standard__string__Object__to_s]))(var281) /* to_s on */; +var160 = counter___standard__Sys___div(var153, var157, var_nb_invok_total); } +((struct instance_standard__NativeArray*)var133)->values[3]=var160; { -standard__file___Object___print(self, var286); /* Direct call file#Object#print on */ +var161 = ((val*(*)(val* self))(var133->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var133); /* native_to_s on */ } -RET_LABEL:; -} -/* method separate_compiler#SeparateCompiler#isset_checks_count for (self: SeparateCompiler): Int */ -long nit___nit__SeparateCompiler___isset_checks_count(val* self) { -long var /* : Int */; -long var1 /* : Int */; -var1 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___isset_checks_count].l; /* _isset_checks_count on */ -var = var1; -RET_LABEL:; -return var; +varonce132 = var133; +{ +nit___nit__ToolContext___info(var_tc, var161, 2l); /* Direct call toolcontext#ToolContext#info on */ } -/* method separate_compiler#SeparateCompiler#isset_checks_count= for (self: SeparateCompiler, Int) */ -void nit___nit__SeparateCompiler___isset_checks_count_61d(val* self, long p0) { -self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___isset_checks_count].l = p0; /* _isset_checks_count on */ RET_LABEL:; } -/* method separate_compiler#SeparateCompiler#attr_read_count for (self: SeparateCompiler): Int */ -long nit___nit__SeparateCompiler___attr_read_count(val* self) { -long var /* : Int */; -long var1 /* : Int */; -var1 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___attr_read_count].l; /* _attr_read_count on */ -var = var1; -RET_LABEL:; -return var; +/* method separate_compiler#SeparateCompiler#display_sizes for (self: SeparateCompiler) */ +void nit___nit__SeparateCompiler___display_sizes(val* self) { +val* var /* : Sys */; +static val* varonce; +val* var1 /* : String */; +char* var2 /* : NativeString */; +val* var3 /* : FlatString */; +val* var4 /* : Sys */; +static val* varonce5; +val* var6 /* : String */; +char* var7 /* : NativeString */; +val* var8 /* : FlatString */; +long var_total /* var total: Int */; +long var_holes /* var holes: Int */; +val* var9 /* : Map[MType, Array[nullable MType]] */; +val* var11 /* : Map[MType, Array[nullable MType]] */; +val* var_ /* var : Map[MType, Array[nullable MType]] */; +val* var12 /* : MapIterator[nullable Object, nullable Object] */; +val* var_13 /* var : MapIterator[MType, Array[nullable MType]] */; +short int var14 /* : Bool */; +val* var15 /* : nullable Object */; +val* var_t /* var t: MType */; +val* var16 /* : nullable Object */; +val* var_table /* var table: Array[nullable MType] */; +long var17 /* : Int */; +long var19 /* : Int */; +long var20 /* : Int */; +short int var22 /* : Bool */; +int cltype; +int idtype; +const char* var_class_name; +long var23 /* : Int */; +val* var_24 /* var : Array[nullable MType] */; +val* var25 /* : ArrayIterator[nullable Object] */; +val* var_26 /* var : ArrayIterator[nullable MType] */; +short int var27 /* : Bool */; +val* var28 /* : nullable Object */; +val* var_e /* var e: nullable MType */; +short int var29 /* : Bool */; +short int var30 /* : Bool */; +val* var_other /* var other: nullable Object */; +short int var32 /* : Bool */; +short int var34 /* : Bool */; +long var35 /* : Int */; +short int var37 /* : Bool */; +int cltype38; +int idtype39; +const char* var_class_name40; +long var41 /* : Int */; +val* var44 /* : Sys */; +val* var46 /* : NativeArray[String] */; +static val* varonce45; +static val* varonce47; +val* var48 /* : String */; +char* var49 /* : NativeString */; +val* var50 /* : FlatString */; +static val* varonce51; +val* var52 /* : String */; +char* var53 /* : NativeString */; +val* var54 /* : FlatString */; +val* var55 /* : String */; +val* var56 /* : String */; +val* var57 /* : String */; +val* var58 /* : Sys */; +static val* varonce59; +val* var60 /* : String */; +char* var61 /* : NativeString */; +val* var62 /* : FlatString */; +val* var63 /* : Sys */; +static val* varonce64; +val* var65 /* : String */; +char* var66 /* : NativeString */; +val* var67 /* : FlatString */; +val* var68 /* : Map[MClassType, Array[nullable MType]] */; +val* var70 /* : Map[MClassType, Array[nullable MType]] */; +val* var_71 /* var : Map[MClassType, Array[nullable MType]] */; +val* var72 /* : MapIterator[nullable Object, nullable Object] */; +val* var_73 /* var : MapIterator[MClassType, Array[nullable MType]] */; +short int var74 /* : Bool */; +val* var75 /* : nullable Object */; +val* var_t76 /* var t: MClassType */; +val* var77 /* : nullable Object */; +val* var_table78 /* var table: Array[nullable MType] */; +long var79 /* : Int */; +long var81 /* : Int */; +long var82 /* : Int */; +short int var84 /* : Bool */; +int cltype85; +int idtype86; +const char* var_class_name87; +long var88 /* : Int */; +val* var_89 /* var : Array[nullable MType] */; +val* var90 /* : ArrayIterator[nullable Object] */; +val* var_91 /* var : ArrayIterator[nullable MType] */; +short int var92 /* : Bool */; +val* var93 /* : nullable Object */; +val* var_e94 /* var e: nullable MType */; +short int var95 /* : Bool */; +short int var96 /* : Bool */; +short int var98 /* : Bool */; +short int var100 /* : Bool */; +long var101 /* : Int */; +short int var103 /* : Bool */; +int cltype104; +int idtype105; +const char* var_class_name106; +long var107 /* : Int */; +val* var111 /* : Sys */; +val* var113 /* : NativeArray[String] */; +static val* varonce112; +static val* varonce114; +val* var115 /* : String */; +char* var116 /* : NativeString */; +val* var117 /* : FlatString */; +static val* varonce118; +val* var119 /* : String */; +char* var120 /* : NativeString */; +val* var121 /* : FlatString */; +val* var122 /* : String */; +val* var123 /* : String */; +val* var124 /* : String */; +val* var125 /* : Sys */; +static val* varonce126; +val* var127 /* : String */; +char* var128 /* : NativeString */; +val* var129 /* : FlatString */; +val* var130 /* : Sys */; +static val* varonce131; +val* var132 /* : String */; +char* var133 /* : NativeString */; +val* var134 /* : FlatString */; +val* var135 /* : Map[MClass, Array[nullable MPropDef]] */; +val* var137 /* : Map[MClass, Array[nullable MPropDef]] */; +val* var_138 /* var : Map[MClass, Array[nullable MPropDef]] */; +val* var139 /* : MapIterator[nullable Object, nullable Object] */; +val* var_140 /* var : MapIterator[MClass, Array[nullable MPropDef]] */; +short int var141 /* : Bool */; +val* var142 /* : nullable Object */; +val* var_t143 /* var t: MClass */; +val* var144 /* : nullable Object */; +val* var_table145 /* var table: Array[nullable MPropDef] */; +long var146 /* : Int */; +long var148 /* : Int */; +long var149 /* : Int */; +short int var151 /* : Bool */; +int cltype152; +int idtype153; +const char* var_class_name154; +long var155 /* : Int */; +val* var_156 /* var : Array[nullable MPropDef] */; +val* var157 /* : ArrayIterator[nullable Object] */; +val* var_158 /* var : ArrayIterator[nullable MPropDef] */; +short int var159 /* : Bool */; +val* var160 /* : nullable Object */; +val* var_e161 /* var e: nullable MPropDef */; +short int var162 /* : Bool */; +short int var163 /* : Bool */; +short int var165 /* : Bool */; +short int var167 /* : Bool */; +long var168 /* : Int */; +short int var170 /* : Bool */; +int cltype171; +int idtype172; +const char* var_class_name173; +long var174 /* : Int */; +val* var178 /* : Sys */; +val* var180 /* : NativeArray[String] */; +static val* varonce179; +static val* varonce181; +val* var182 /* : String */; +char* var183 /* : NativeString */; +val* var184 /* : FlatString */; +static val* varonce185; +val* var186 /* : String */; +char* var187 /* : NativeString */; +val* var188 /* : FlatString */; +val* var189 /* : String */; +val* var190 /* : String */; +val* var191 /* : String */; +val* var192 /* : Sys */; +static val* varonce193; +val* var194 /* : String */; +char* var195 /* : NativeString */; +val* var196 /* : FlatString */; +val* var197 /* : Sys */; +static val* varonce198; +val* var199 /* : String */; +char* var200 /* : NativeString */; +val* var201 /* : FlatString */; +val* var202 /* : Map[MClass, Array[nullable MProperty]] */; +val* var204 /* : Map[MClass, Array[nullable MProperty]] */; +val* var_205 /* var : Map[MClass, Array[nullable MProperty]] */; +val* var206 /* : MapIterator[nullable Object, nullable Object] */; +val* var_207 /* var : MapIterator[MClass, Array[nullable MProperty]] */; +short int var208 /* : Bool */; +val* var209 /* : nullable Object */; +val* var_t210 /* var t: MClass */; +val* var211 /* : nullable Object */; +val* var_table212 /* var table: Array[nullable MProperty] */; +long var213 /* : Int */; +long var215 /* : Int */; +long var216 /* : Int */; +short int var218 /* : Bool */; +int cltype219; +int idtype220; +const char* var_class_name221; +long var222 /* : Int */; +val* var_223 /* var : Array[nullable MProperty] */; +val* var224 /* : ArrayIterator[nullable Object] */; +val* var_225 /* var : ArrayIterator[nullable MProperty] */; +short int var226 /* : Bool */; +val* var227 /* : nullable Object */; +val* var_e228 /* var e: nullable MProperty */; +short int var229 /* : Bool */; +short int var230 /* : Bool */; +short int var232 /* : Bool */; +short int var234 /* : Bool */; +long var235 /* : Int */; +short int var237 /* : Bool */; +int cltype238; +int idtype239; +const char* var_class_name240; +long var241 /* : Int */; +val* var245 /* : Sys */; +val* var247 /* : NativeArray[String] */; +static val* varonce246; +static val* varonce248; +val* var249 /* : String */; +char* var250 /* : NativeString */; +val* var251 /* : FlatString */; +static val* varonce252; +val* var253 /* : String */; +char* var254 /* : NativeString */; +val* var255 /* : FlatString */; +val* var256 /* : String */; +val* var257 /* : String */; +val* var258 /* : String */; +var = glob_sys; +if (likely(varonce!=NULL)) { +var1 = varonce; +} else { +var2 = "# size of subtyping tables"; +var3 = standard___standard__NativeString___to_s_with_length(var2, 26l); +var1 = var3; +varonce = var1; } -/* method separate_compiler#SeparateCompiler#attr_read_count= for (self: SeparateCompiler, Int) */ -void nit___nit__SeparateCompiler___attr_read_count_61d(val* self, long p0) { -self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___attr_read_count].l = p0; /* _attr_read_count on */ -RET_LABEL:; +{ +standard__file___Sys___print(var, var1); /* Direct call file#Sys#print on */ } -/* method separate_compiler#SeparateCompiler#display_isset_checks for (self: SeparateCompiler) */ -void nit___nit__SeparateCompiler___display_isset_checks(val* self) { -static val* varonce; -val* var /* : String */; -char* var1 /* : NativeString */; -long var2 /* : Int */; -val* var3 /* : FlatString */; -static val* varonce4; -val* var5 /* : String */; -char* var6 /* : NativeString */; -long var7 /* : Int */; -val* var8 /* : FlatString */; -long var9 /* : Int */; -long var11 /* : Int */; -val* var12 /* : Array[Object] */; -long var13 /* : Int */; -val* var14 /* : NativeArray[Object] */; -val* var15 /* : Object */; -val* var16 /* : String */; -static val* varonce17; -val* var18 /* : String */; -char* var19 /* : NativeString */; -long var20 /* : Int */; -val* var21 /* : FlatString */; -static val* varonce22; -val* var23 /* : String */; -char* var24 /* : NativeString */; -long var25 /* : Int */; -val* var26 /* : FlatString */; -long var27 /* : Int */; -long var29 /* : Int */; -val* var30 /* : Array[Object] */; -long var31 /* : Int */; -val* var32 /* : NativeArray[Object] */; -val* var33 /* : Object */; -val* var34 /* : String */; -if (varonce) { -var = varonce; +var4 = glob_sys; +if (likely(varonce5!=NULL)) { +var6 = varonce5; } else { -var1 = "# total number of compiled attribute reads"; -var2 = 42; -var3 = standard___standard__NativeString___to_s_with_length(var1, var2); -var = var3; -varonce = var; +var7 = "\ttotal \tholes"; +var8 = standard___standard__NativeString___to_s_with_length(var7, 13l); +var6 = var8; +varonce5 = var6; } { -standard__file___Object___print(self, var); /* Direct call file#Object#print on */ -} -if (varonce4) { -var5 = varonce4; -} else { -var6 = "\11"; -var7 = 1; -var8 = standard___standard__NativeString___to_s_with_length(var6, var7); -var5 = var8; -varonce4 = var5; +standard__file___Sys___print(var4, var6); /* Direct call file#Sys#print on */ } +var_total = 0l; +var_holes = 0l; { -{ /* Inline separate_compiler#SeparateCompiler#attr_read_count (self) on */ -var11 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___attr_read_count].l; /* _attr_read_count on */ +{ /* Inline separate_compiler#SeparateCompiler#type_tables (self) on */ +var11 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___type_tables].val; /* _type_tables on */ +if (unlikely(var11 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _type_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 1051); +fatal_exit(1); +} var9 = var11; RET_LABEL10:(void)0; } } -var12 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var12 = array_instance Array[Object] */ -var13 = 2; -var14 = NEW_standard__NativeArray(var13, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var14)->values[0] = (val*) var5; -var15 = BOX_standard__Int(var9); /* autobox from Int to Object */ -((struct instance_standard__NativeArray*)var14)->values[1] = (val*) var15; +var_ = var9; { -((void (*)(val* self, val* p0, long p1))(var12->class->vft[COLOR_standard__array__Array__with_native]))(var12, var14, var13) /* with_native on */; -} +var12 = ((val*(*)(val* self))((((long)var_&3)?class_info[((long)var_&3)]:var_->class)->vft[COLOR_standard__abstract_collection__MapRead__iterator]))(var_); /* iterator on */ } +var_13 = var12; +for(;;) { { -var16 = ((val* (*)(val* self))(var12->class->vft[COLOR_standard__string__Object__to_s]))(var12) /* to_s on */; +var14 = ((short int(*)(val* self))((((long)var_13&3)?class_info[((long)var_13&3)]:var_13->class)->vft[COLOR_standard__abstract_collection__MapIterator__is_ok]))(var_13); /* is_ok on */ } +if (var14){ { -standard__file___Object___print(self, var16); /* Direct call file#Object#print on */ -} -if (varonce17) { -var18 = varonce17; -} else { -var19 = "# total number of compiled isset-checks"; -var20 = 39; -var21 = standard___standard__NativeString___to_s_with_length(var19, var20); -var18 = var21; -varonce17 = var18; +var15 = ((val*(*)(val* self))((((long)var_13&3)?class_info[((long)var_13&3)]:var_13->class)->vft[COLOR_standard__abstract_collection__MapIterator__key]))(var_13); /* key on */ } +var_t = var15; { -standard__file___Object___print(self, var18); /* Direct call file#Object#print on */ -} -if (varonce22) { -var23 = varonce22; -} else { -var24 = "\11"; -var25 = 1; -var26 = standard___standard__NativeString___to_s_with_length(var24, var25); -var23 = var26; -varonce22 = var23; +var16 = ((val*(*)(val* self))((((long)var_13&3)?class_info[((long)var_13&3)]:var_13->class)->vft[COLOR_standard__abstract_collection__MapIterator__item]))(var_13); /* item on */ } +var_table = var16; { -{ /* Inline separate_compiler#SeparateCompiler#isset_checks_count (self) on */ -var29 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___isset_checks_count].l; /* _isset_checks_count on */ -var27 = var29; -RET_LABEL28:(void)0; +{ /* Inline array#AbstractArrayRead#length (var_table) on */ +var19 = var_table->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ +var17 = var19; +RET_LABEL18:(void)0; } } -var30 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var30 = array_instance Array[Object] */ -var31 = 2; -var32 = NEW_standard__NativeArray(var31, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var32)->values[0] = (val*) var23; -var33 = BOX_standard__Int(var27); /* autobox from Int to Object */ -((struct instance_standard__NativeArray*)var32)->values[1] = (val*) var33; { -((void (*)(val* self, val* p0, long p1))(var30->class->vft[COLOR_standard__array__Array__with_native]))(var30, var32, var31) /* with_native on */; +{ /* Inline kernel#Int#+ (var_total,var17) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var22 = 1; /* easy isa OTHER*/ +if (unlikely(!var22)) { +var_class_name = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 537); +fatal_exit(1); } +var23 = var_total + var17; +var20 = var23; +goto RET_LABEL21; +RET_LABEL21:(void)0; } -{ -var34 = ((val* (*)(val* self))(var30->class->vft[COLOR_standard__string__Object__to_s]))(var30) /* to_s on */; } +var_total = var20; +var_24 = var_table; { -standard__file___Object___print(self, var34); /* Direct call file#Object#print on */ +var25 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_24); } -RET_LABEL:; -} -/* method separate_compiler#SeparateCompiler#compile_nitni_structs for (self: SeparateCompiler) */ -void nit___nit__SeparateCompiler___nit__abstract_compiler__AbstractCompiler__compile_nitni_structs(val* self) { -val* var /* : CodeWriter */; -val* var2 /* : CodeWriter */; -static val* varonce; -val* var3 /* : String */; -char* var4 /* : NativeString */; -long var5 /* : Int */; -val* var6 /* : FlatString */; +var_26 = var25; +for(;;) { { -{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ -var2 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ -if (unlikely(var2 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 523); -show_backtrace(1); -} -var = var2; -RET_LABEL1:(void)0; +var27 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_26); } +if (var27){ +{ +var28 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_26); } -if (varonce) { -var3 = varonce; +var_e = var28; +if (var_e == NULL) { +var29 = 1; /* is null */ } else { -var4 = "struct nitni_instance {\n\11struct nitni_instance *next,\n\11\11*prev; /* adjacent global references in global list */\n\11int count; /* number of time this global reference has been marked */\n\11struct instance *value;\n};\n"; -var5 = 210; -var6 = standard___standard__NativeString___to_s_with_length(var4, var5); -var3 = var6; -varonce = var3; +var29 = 0; /* arg is null but recv is not */ } +if (0) { +{ /* Inline kernel#Object#== (var_e,((val*)NULL)) on */ +var_other = ((val*)NULL); { -nit___nit__CodeWriter___add_decl(var, var3); /* Direct call abstract_compiler#CodeWriter#add_decl on */ +{ /* Inline kernel#Object#is_same_instance (var_e,var_other) on */ +var34 = var_e == var_other; +var32 = var34; +goto RET_LABEL33; +RET_LABEL33:(void)0; } -{ -((void (*)(val* self))(self->class->vft[COLOR_nit___nit__SeparateCompiler___nit__abstract_compiler__AbstractCompiler__compile_nitni_structs]))(self) /* compile_nitni_structs on */; } -RET_LABEL:; +var30 = var32; +goto RET_LABEL31; +RET_LABEL31:(void)0; } -/* method separate_compiler#SeparateCompiler#finalize_ffi_for_module for (self: SeparateCompiler, MModule) */ -void nit___nit__SeparateCompiler___nit__abstract_compiler__AbstractCompiler__finalize_ffi_for_module(val* self, val* p0) { -val* var_mmodule /* var mmodule: MModule */; -val* var /* : MModule */; -val* var2 /* : MModule */; -val* var_old_module /* var old_module: MModule */; -var_mmodule = p0; +var29 = var30; +} +if (var29){ { -{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ -var2 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ -if (unlikely(var2 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); -show_backtrace(1); +{ /* Inline kernel#Int#+ (var_holes,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var37 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var37)) { +var_class_name40 = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name40); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 537); +fatal_exit(1); +} +var41 = var_holes + 1l; +var35 = var41; +goto RET_LABEL36; +RET_LABEL36:(void)0; } -var = var2; -RET_LABEL1:(void)0; } +var_holes = var35; +} else { } -var_old_module = var; { -{ /* Inline abstract_compiler#AbstractCompiler#mainmodule= (self,var_mmodule) on */ -self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val = var_mmodule; /* _mainmodule on */ -RET_LABEL3:(void)0; +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_26); /* Direct call array#ArrayIterator#next on */ +} +} else { +goto BREAK_label; } } +BREAK_label: (void)0; { -((void (*)(val* self, val* p0))(self->class->vft[COLOR_nit___nit__SeparateCompiler___nit__abstract_compiler__AbstractCompiler__finalize_ffi_for_module]))(self, p0) /* finalize_ffi_for_module on */; +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__finish(var_26); /* Direct call array#ArrayIterator#finish on */ } { -{ /* Inline abstract_compiler#AbstractCompiler#mainmodule= (self,var_old_module) on */ -self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val = var_old_module; /* _mainmodule on */ -RET_LABEL4:(void)0; +((void(*)(val* self))((((long)var_13&3)?class_info[((long)var_13&3)]:var_13->class)->vft[COLOR_standard__abstract_collection__MapIterator__next]))(var_13); /* next on */ } +} else { +goto BREAK_label42; } -RET_LABEL:; } -/* method separate_compiler#SeparateCompilerVisitor#adapt_signature for (self: SeparateCompilerVisitor, MMethodDef, Array[RuntimeVariable]) */ -void nit___nit__SeparateCompilerVisitor___nit__abstract_compiler__AbstractCompilerVisitor__adapt_signature(val* self, val* p0, val* p1) { -val* var_m /* var m: MMethodDef */; -val* var_args /* var args: Array[RuntimeVariable] */; -val* var /* : nullable MSignature */; -val* var2 /* : nullable MSignature */; -val* var3 /* : MClassDef */; -val* var5 /* : MClassDef */; -val* var6 /* : MClassType */; -val* var8 /* : MClassType */; -val* var9 /* : MClassDef */; -val* var11 /* : MClassDef */; -val* var12 /* : MClassType */; -val* var14 /* : MClassType */; -val* var15 /* : MClassDef */; -val* var17 /* : MClassDef */; -val* var18 /* : MModule */; -val* var20 /* : MModule */; -short int var21 /* : Bool */; -val* var22 /* : MSignature */; -val* var_msignature /* var msignature: MSignature */; -val* var23 /* : nullable Object */; -val* var_recv /* var recv: RuntimeVariable */; -val* var24 /* : MType */; -val* var26 /* : MType */; -val* var27 /* : String */; -val* var28 /* : MClassDef */; -val* var30 /* : MClassDef */; -val* var31 /* : MClass */; -val* var33 /* : MClass */; -val* var34 /* : MClassType */; -val* var36 /* : MClassType */; -val* var37 /* : String */; -short int var38 /* : Bool */; -val* var_other /* var other: nullable Object */; -short int var40 /* : Bool */; -short int var41 /* : Bool */; -val* var42 /* : nullable Object */; -val* var43 /* : MClassDef */; -val* var45 /* : MClassDef */; -val* var46 /* : MClass */; -val* var48 /* : MClass */; -val* var49 /* : MClassType */; -val* var51 /* : MClassType */; -val* var52 /* : RuntimeVariable */; -long var53 /* : Int */; -long var_i /* var i: Int */; -long var54 /* : Int */; -long var_ /* var : Int */; -short int var55 /* : Bool */; -short int var57 /* : Bool */; -int cltype; -int idtype; -const char* var_class_name; -short int var58 /* : Bool */; -val* var59 /* : Array[MParameter] */; -val* var61 /* : Array[MParameter] */; -val* var62 /* : nullable Object */; -val* var63 /* : MType */; -val* var65 /* : MType */; -val* var_t /* var t: MType */; -long var66 /* : Int */; -long var68 /* : Int */; -short int var69 /* : Bool */; -short int var71 /* : Bool */; -long var72 /* : Int */; -long var73 /* : Int */; -short int var75 /* : Bool */; -int cltype76; -int idtype77; -const char* var_class_name78; -long var79 /* : Int */; -val* var80 /* : nullable Object */; -val* var81 /* : MType */; -val* var83 /* : MType */; -long var84 /* : Int */; -long var85 /* : Int */; -short int var87 /* : Bool */; -int cltype88; -int idtype89; -const char* var_class_name90; -long var91 /* : Int */; -long var92 /* : Int */; -long var93 /* : Int */; -short int var95 /* : Bool */; -int cltype96; -int idtype97; -const char* var_class_name98; -long var99 /* : Int */; -val* var100 /* : nullable Object */; -val* var101 /* : RuntimeVariable */; -long var102 /* : Int */; -long var103 /* : Int */; -var_m = p0; -var_args = p1; +BREAK_label42: (void)0; { -{ /* Inline model#MMethodDef#msignature (var_m) on */ -var2 = var_m->attrs[COLOR_nit__model__MMethodDef___msignature].val; /* _msignature on */ -var = var2; -RET_LABEL1:(void)0; +{ /* Inline abstract_collection#MapIterator#finish (var_13) on */ +RET_LABEL43:(void)0; } } -{ -{ /* Inline model#MPropDef#mclassdef (var_m) on */ -var5 = var_m->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ -if (unlikely(var5 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2010); -show_backtrace(1); +var44 = glob_sys; +if (unlikely(varonce45==NULL)) { +var46 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce47!=NULL)) { +var48 = varonce47; +} else { +var49 = "\t"; +var50 = standard___standard__NativeString___to_s_with_length(var49, 1l); +var48 = var50; +varonce47 = var48; } -var3 = var5; -RET_LABEL4:(void)0; +((struct instance_standard__NativeArray*)var46)->values[0]=var48; +if (likely(varonce51!=NULL)) { +var52 = varonce51; +} else { +var53 = "\t"; +var54 = standard___standard__NativeString___to_s_with_length(var53, 1l); +var52 = var54; +varonce51 = var52; } +((struct instance_standard__NativeArray*)var46)->values[2]=var52; +} else { +var46 = varonce45; +varonce45 = NULL; } +var55 = standard__string___Int___Object__to_s(var_total); +((struct instance_standard__NativeArray*)var46)->values[1]=var55; +var56 = standard__string___Int___Object__to_s(var_holes); +((struct instance_standard__NativeArray*)var46)->values[3]=var56; { -{ /* Inline model#MClassDef#bound_mtype (var3) on */ -var8 = var3->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ -if (unlikely(var8 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 495); -show_backtrace(1); -} -var6 = var8; -RET_LABEL7:(void)0; -} +var57 = ((val*(*)(val* self))(var46->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var46); /* native_to_s on */ } +varonce45 = var46; { -{ /* Inline model#MPropDef#mclassdef (var_m) on */ -var11 = var_m->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ -if (unlikely(var11 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2010); -show_backtrace(1); -} -var9 = var11; -RET_LABEL10:(void)0; +standard__file___Sys___print(var44, var57); /* Direct call file#Sys#print on */ } +var58 = glob_sys; +if (likely(varonce59!=NULL)) { +var60 = varonce59; +} else { +var61 = "# size of resolution tables"; +var62 = standard___standard__NativeString___to_s_with_length(var61, 27l); +var60 = var62; +varonce59 = var60; } { -{ /* Inline model#MClassDef#bound_mtype (var9) on */ -var14 = var9->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ -if (unlikely(var14 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 495); -show_backtrace(1); +standard__file___Sys___print(var58, var60); /* Direct call file#Sys#print on */ } -var12 = var14; -RET_LABEL13:(void)0; +var63 = glob_sys; +if (likely(varonce64!=NULL)) { +var65 = varonce64; +} else { +var66 = "\ttotal \tholes"; +var67 = standard___standard__NativeString___to_s_with_length(var66, 13l); +var65 = var67; +varonce64 = var65; } +{ +standard__file___Sys___print(var63, var65); /* Direct call file#Sys#print on */ } +var_total = 0l; +var_holes = 0l; { -{ /* Inline model#MPropDef#mclassdef (var_m) on */ -var17 = var_m->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ -if (unlikely(var17 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2010); -show_backtrace(1); +{ /* Inline separate_compiler#SeparateCompiler#resolution_tables (self) on */ +var70 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___resolution_tables].val; /* _resolution_tables on */ +if (unlikely(var70 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _resolution_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 1052); +fatal_exit(1); } -var15 = var17; -RET_LABEL16:(void)0; +var68 = var70; +RET_LABEL69:(void)0; } } +var_71 = var68; { -{ /* Inline model#MClassDef#mmodule (var15) on */ -var20 = var15->attrs[COLOR_nit__model__MClassDef___mmodule].val; /* _mmodule on */ -if (unlikely(var20 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mmodule"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 489); -show_backtrace(1); +var72 = ((val*(*)(val* self))((((long)var_71&3)?class_info[((long)var_71&3)]:var_71->class)->vft[COLOR_standard__abstract_collection__MapRead__iterator]))(var_71); /* iterator on */ } -var18 = var20; -RET_LABEL19:(void)0; +var_73 = var72; +for(;;) { +{ +var74 = ((short int(*)(val* self))((((long)var_73&3)?class_info[((long)var_73&3)]:var_73->class)->vft[COLOR_standard__abstract_collection__MapIterator__is_ok]))(var_73); /* is_ok on */ } +if (var74){ +{ +var75 = ((val*(*)(val* self))((((long)var_73&3)?class_info[((long)var_73&3)]:var_73->class)->vft[COLOR_standard__abstract_collection__MapIterator__key]))(var_73); /* key on */ } -var21 = 1; -if (var == NULL) { -PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 960); -show_backtrace(1); -} else { -var22 = nit___nit__MSignature___MType__resolve_for(var, var6, var12, var18, var21); +var_t76 = var75; +{ +var77 = ((val*(*)(val* self))((((long)var_73&3)?class_info[((long)var_73&3)]:var_73->class)->vft[COLOR_standard__abstract_collection__MapIterator__item]))(var_73); /* item on */ } -var_msignature = var22; +var_table78 = var77; { -var23 = standard___standard__SequenceRead___Collection__first(var_args); +{ /* Inline array#AbstractArrayRead#length (var_table78) on */ +var81 = var_table78->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ +var79 = var81; +RET_LABEL80:(void)0; +} } -var_recv = var23; { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_recv) on */ -var26 = var_recv->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var26 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); +{ /* Inline kernel#Int#+ (var_total,var79) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var84 = 1; /* easy isa OTHER*/ +if (unlikely(!var84)) { +var_class_name87 = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name87); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 537); +fatal_exit(1); } -var24 = var26; -RET_LABEL25:(void)0; +var88 = var_total + var79; +var82 = var88; +goto RET_LABEL83; +RET_LABEL83:(void)0; } } +var_total = var82; +var_89 = var_table78; { -var27 = ((val* (*)(val* self))(var24->class->vft[COLOR_nit__abstract_compiler__MType__ctype]))(var24) /* ctype on */; +var90 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_89); } -{ -{ /* Inline model#MPropDef#mclassdef (var_m) on */ -var30 = var_m->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ -if (unlikely(var30 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2010); -show_backtrace(1); +var_91 = var90; +for(;;) { +{ +var92 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_91); } -var28 = var30; -RET_LABEL29:(void)0; +if (var92){ +{ +var93 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_91); } +var_e94 = var93; +if (var_e94 == NULL) { +var95 = 1; /* is null */ +} else { +var95 = 0; /* arg is null but recv is not */ } +if (0) { +{ /* Inline kernel#Object#== (var_e94,((val*)NULL)) on */ +var_other = ((val*)NULL); { -{ /* Inline model#MClassDef#mclass (var28) on */ -var33 = var28->attrs[COLOR_nit__model__MClassDef___mclass].val; /* _mclass on */ -if (unlikely(var33 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 492); -show_backtrace(1); +{ /* Inline kernel#Object#is_same_instance (var_e94,var_other) on */ +var100 = var_e94 == var_other; +var98 = var100; +goto RET_LABEL99; +RET_LABEL99:(void)0; +} } -var31 = var33; -RET_LABEL32:(void)0; +var96 = var98; +goto RET_LABEL97; +RET_LABEL97:(void)0; } +var95 = var96; } +if (var95){ { -{ /* Inline model#MClass#mclass_type (var31) on */ -var36 = var31->attrs[COLOR_nit__model__MClass___mclass_type].val; /* _mclass_type on */ -if (unlikely(var36 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass_type"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 438); -show_backtrace(1); +{ /* Inline kernel#Int#+ (var_holes,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var103 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var103)) { +var_class_name106 = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name106); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 537); +fatal_exit(1); } -var34 = var36; -RET_LABEL35:(void)0; +var107 = var_holes + 1l; +var101 = var107; +goto RET_LABEL102; +RET_LABEL102:(void)0; } } -{ -var37 = nit__abstract_compiler___MClassType___MType__ctype(var34); +var_holes = var101; +} else { } { -{ /* Inline kernel#Object#!= (var27,var37) on */ -var_other = var37; -{ -var40 = ((short int (*)(val* self, val* p0))(var27->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var27, var_other) /* == on */; +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_91); /* Direct call array#ArrayIterator#next on */ } -var41 = !var40; -var38 = var41; -goto RET_LABEL39; -RET_LABEL39:(void)0; +} else { +goto BREAK_label108; } } -if (var38){ +BREAK_label108: (void)0; { -var42 = standard___standard__SequenceRead___Collection__first(var_args); +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__finish(var_91); /* Direct call array#ArrayIterator#finish on */ } { -{ /* Inline model#MPropDef#mclassdef (var_m) on */ -var45 = var_m->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ -if (unlikely(var45 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2010); -show_backtrace(1); +((void(*)(val* self))((((long)var_73&3)?class_info[((long)var_73&3)]:var_73->class)->vft[COLOR_standard__abstract_collection__MapIterator__next]))(var_73); /* next on */ } -var43 = var45; -RET_LABEL44:(void)0; +} else { +goto BREAK_label109; } } +BREAK_label109: (void)0; { -{ /* Inline model#MClassDef#mclass (var43) on */ -var48 = var43->attrs[COLOR_nit__model__MClassDef___mclass].val; /* _mclass on */ -if (unlikely(var48 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 492); -show_backtrace(1); +{ /* Inline abstract_collection#MapIterator#finish (var_73) on */ +RET_LABEL110:(void)0; } -var46 = var48; -RET_LABEL47:(void)0; } +var111 = glob_sys; +if (unlikely(varonce112==NULL)) { +var113 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce114!=NULL)) { +var115 = varonce114; +} else { +var116 = "\t"; +var117 = standard___standard__NativeString___to_s_with_length(var116, 1l); +var115 = var117; +varonce114 = var115; } -{ -{ /* Inline model#MClass#mclass_type (var46) on */ -var51 = var46->attrs[COLOR_nit__model__MClass___mclass_type].val; /* _mclass_type on */ -if (unlikely(var51 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass_type"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 438); -show_backtrace(1); +((struct instance_standard__NativeArray*)var113)->values[0]=var115; +if (likely(varonce118!=NULL)) { +var119 = varonce118; +} else { +var120 = "\t"; +var121 = standard___standard__NativeString___to_s_with_length(var120, 1l); +var119 = var121; +varonce118 = var119; } -var49 = var51; -RET_LABEL50:(void)0; +((struct instance_standard__NativeArray*)var113)->values[2]=var119; +} else { +var113 = varonce112; +varonce112 = NULL; } +var122 = standard__string___Int___Object__to_s(var_total); +((struct instance_standard__NativeArray*)var113)->values[1]=var122; +var123 = standard__string___Int___Object__to_s(var_holes); +((struct instance_standard__NativeArray*)var113)->values[3]=var123; +{ +var124 = ((val*(*)(val* self))(var113->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var113); /* native_to_s on */ } +varonce112 = var113; { -var52 = nit___nit__SeparateCompilerVisitor___nit__abstract_compiler__AbstractCompilerVisitor__autobox(self, var42, var49); +standard__file___Sys___print(var111, var124); /* Direct call file#Sys#print on */ +} +var125 = glob_sys; +if (likely(varonce126!=NULL)) { +var127 = varonce126; +} else { +var128 = "# size of methods tables"; +var129 = standard___standard__NativeString___to_s_with_length(var128, 24l); +var127 = var129; +varonce126 = var127; } { -standard___standard__Sequence___first_61d(var_args, var52); /* Direct call abstract_collection#Sequence#first= on */ +standard__file___Sys___print(var125, var127); /* Direct call file#Sys#print on */ } +var130 = glob_sys; +if (likely(varonce131!=NULL)) { +var132 = varonce131; } else { +var133 = "\ttotal \tholes"; +var134 = standard___standard__NativeString___to_s_with_length(var133, 13l); +var132 = var134; +varonce131 = var132; } -var53 = 0; -var_i = var53; { -var54 = nit___nit__MSignature___arity(var_msignature); +standard__file___Sys___print(var130, var132); /* Direct call file#Sys#print on */ } -var_ = var54; -for(;;) { +var_total = 0l; +var_holes = 0l; { -{ /* Inline kernel#Int#< (var_i,var_) on */ -/* Covariant cast for argument 0 (i) isa OTHER */ -/* isa OTHER */ -var57 = 1; /* easy isa OTHER*/ -if (unlikely(!var57)) { -var_class_name = type_standard__Int.name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); -PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 410); -show_backtrace(1); +{ /* Inline separate_compiler#SeparateCompiler#method_tables (self) on */ +var137 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___method_tables].val; /* _method_tables on */ +if (unlikely(var137 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _method_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 1053); +fatal_exit(1); } -var58 = var_i < var_; -var55 = var58; -goto RET_LABEL56; -RET_LABEL56:(void)0; +var135 = var137; +RET_LABEL136:(void)0; } } -if (var55){ +var_138 = var135; { -{ /* Inline model#MSignature#mparameters (var_msignature) on */ -var61 = var_msignature->attrs[COLOR_nit__model__MSignature___mparameters].val; /* _mparameters on */ -if (unlikely(var61 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mparameters"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1592); -show_backtrace(1); +var139 = ((val*(*)(val* self))((((long)var_138&3)?class_info[((long)var_138&3)]:var_138->class)->vft[COLOR_standard__abstract_collection__MapRead__iterator]))(var_138); /* iterator on */ } -var59 = var61; -RET_LABEL60:(void)0; +var_140 = var139; +for(;;) { +{ +var141 = ((short int(*)(val* self))((((long)var_140&3)?class_info[((long)var_140&3)]:var_140->class)->vft[COLOR_standard__abstract_collection__MapIterator__is_ok]))(var_140); /* is_ok on */ } +if (var141){ +{ +var142 = ((val*(*)(val* self))((((long)var_140&3)?class_info[((long)var_140&3)]:var_140->class)->vft[COLOR_standard__abstract_collection__MapIterator__key]))(var_140); /* key on */ } +var_t143 = var142; { -var62 = standard___standard__Array___standard__abstract_collection__SequenceRead___91d_93d(var59, var_i); +var144 = ((val*(*)(val* self))((((long)var_140&3)?class_info[((long)var_140&3)]:var_140->class)->vft[COLOR_standard__abstract_collection__MapIterator__item]))(var_140); /* item on */ } +var_table145 = var144; { -{ /* Inline model#MParameter#mtype (var62) on */ -var65 = var62->attrs[COLOR_nit__model__MParameter___mtype].val; /* _mtype on */ -if (unlikely(var65 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1690); -show_backtrace(1); +{ /* Inline array#AbstractArrayRead#length (var_table145) on */ +var148 = var_table145->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ +var146 = var148; +RET_LABEL147:(void)0; } -var63 = var65; -RET_LABEL64:(void)0; +} +{ +{ /* Inline kernel#Int#+ (var_total,var146) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var151 = 1; /* easy isa OTHER*/ +if (unlikely(!var151)) { +var_class_name154 = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name154); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 537); +fatal_exit(1); +} +var155 = var_total + var146; +var149 = var155; +goto RET_LABEL150; +RET_LABEL150:(void)0; } } -var_t = var63; +var_total = var149; +var_156 = var_table145; { -{ /* Inline model#MSignature#vararg_rank (var_msignature) on */ -var68 = var_msignature->attrs[COLOR_nit__model__MSignature___vararg_rank].l; /* _vararg_rank on */ -var66 = var68; -RET_LABEL67:(void)0; +var157 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_156); } +var_158 = var157; +for(;;) { +{ +var159 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_158); } +if (var159){ { -{ /* Inline kernel#Int#== (var_i,var66) on */ -var71 = var_i == var66; -var69 = var71; -goto RET_LABEL70; -RET_LABEL70:(void)0; +var160 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_158); } +var_e161 = var160; +if (var_e161 == NULL) { +var162 = 1; /* is null */ +} else { +var162 = 0; /* arg is null but recv is not */ } -if (var69){ -var72 = 1; +if (0) { +{ /* Inline kernel#Object#== (var_e161,((val*)NULL)) on */ +var_other = ((val*)NULL); { -{ /* Inline kernel#Int#+ (var_i,var72) on */ -/* Covariant cast for argument 0 (i) isa OTHER */ -/* isa OTHER */ -var75 = 1; /* easy isa OTHER*/ -if (unlikely(!var75)) { -var_class_name78 = type_standard__Int.name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name78); -PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413); -show_backtrace(1); +{ /* Inline kernel#Object#is_same_instance (var_e161,var_other) on */ +var167 = var_e161 == var_other; +var165 = var167; +goto RET_LABEL166; +RET_LABEL166:(void)0; } -var79 = var_i + var72; -var73 = var79; -goto RET_LABEL74; -RET_LABEL74:(void)0; } +var163 = var165; +goto RET_LABEL164; +RET_LABEL164:(void)0; } -{ -var80 = standard___standard__Array___standard__abstract_collection__SequenceRead___91d_93d(var_args, var73); +var162 = var163; } +if (var162){ { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var80) on */ -var83 = var80->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var83 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); +{ /* Inline kernel#Int#+ (var_holes,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var170 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var170)) { +var_class_name173 = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name173); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 537); +fatal_exit(1); } -var81 = var83; -RET_LABEL82:(void)0; +var174 = var_holes + 1l; +var168 = var174; +goto RET_LABEL169; +RET_LABEL169:(void)0; } } -var_t = var81; +var_holes = var168; } else { } -var84 = 1; { -{ /* Inline kernel#Int#+ (var_i,var84) on */ -/* Covariant cast for argument 0 (i) isa OTHER */ -/* isa OTHER */ -var87 = 1; /* easy isa OTHER*/ -if (unlikely(!var87)) { -var_class_name90 = type_standard__Int.name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name90); -PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413); -show_backtrace(1); +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_158); /* Direct call array#ArrayIterator#next on */ } -var91 = var_i + var84; -var85 = var91; -goto RET_LABEL86; -RET_LABEL86:(void)0; +} else { +goto BREAK_label175; } } -var92 = 1; +BREAK_label175: (void)0; { -{ /* Inline kernel#Int#+ (var_i,var92) on */ -/* Covariant cast for argument 0 (i) isa OTHER */ -/* isa OTHER */ -var95 = 1; /* easy isa OTHER*/ -if (unlikely(!var95)) { -var_class_name98 = type_standard__Int.name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name98); -PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413); -show_backtrace(1); +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__finish(var_158); /* Direct call array#ArrayIterator#finish on */ } -var99 = var_i + var92; -var93 = var99; -goto RET_LABEL94; -RET_LABEL94:(void)0; +{ +((void(*)(val* self))((((long)var_140&3)?class_info[((long)var_140&3)]:var_140->class)->vft[COLOR_standard__abstract_collection__MapIterator__next]))(var_140); /* next on */ } +} else { +goto BREAK_label176; } -{ -var100 = standard___standard__Array___standard__abstract_collection__SequenceRead___91d_93d(var_args, var93); } +BREAK_label176: (void)0; { -var101 = nit___nit__SeparateCompilerVisitor___nit__abstract_compiler__AbstractCompilerVisitor__autobox(self, var100, var_t); +{ /* Inline abstract_collection#MapIterator#finish (var_140) on */ +RET_LABEL177:(void)0; } -{ -standard___standard__Array___standard__abstract_collection__Sequence___91d_93d_61d(var_args, var85, var101); /* Direct call array#Array#[]= on */ } -var102 = 1; -{ -var103 = standard___standard__Int___Discrete__successor(var_i, var102); +var178 = glob_sys; +if (unlikely(varonce179==NULL)) { +var180 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce181!=NULL)) { +var182 = varonce181; +} else { +var183 = "\t"; +var184 = standard___standard__NativeString___to_s_with_length(var183, 1l); +var182 = var184; +varonce181 = var182; } -var_i = var103; +((struct instance_standard__NativeArray*)var180)->values[0]=var182; +if (likely(varonce185!=NULL)) { +var186 = varonce185; } else { -goto BREAK_label; +var187 = "\t"; +var188 = standard___standard__NativeString___to_s_with_length(var187, 1l); +var186 = var188; +varonce185 = var186; } +((struct instance_standard__NativeArray*)var180)->values[2]=var186; +} else { +var180 = varonce179; +varonce179 = NULL; } -BREAK_label: (void)0; -RET_LABEL:; +var189 = standard__string___Int___Object__to_s(var_total); +((struct instance_standard__NativeArray*)var180)->values[1]=var189; +var190 = standard__string___Int___Object__to_s(var_holes); +((struct instance_standard__NativeArray*)var180)->values[3]=var190; +{ +var191 = ((val*(*)(val* self))(var180->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var180); /* native_to_s on */ } -/* method separate_compiler#SeparateCompilerVisitor#unbox_signature_extern for (self: SeparateCompilerVisitor, MMethodDef, Array[RuntimeVariable]) */ -void nit___nit__SeparateCompilerVisitor___nit__abstract_compiler__AbstractCompilerVisitor__unbox_signature_extern(val* self, val* p0, val* p1) { -val* var_m /* var m: MMethodDef */; -val* var_args /* var args: Array[RuntimeVariable] */; -val* var /* : nullable MSignature */; -val* var2 /* : nullable MSignature */; -val* var3 /* : MClassDef */; -val* var5 /* : MClassDef */; -val* var6 /* : MClassType */; -val* var8 /* : MClassType */; -val* var9 /* : MClassDef */; -val* var11 /* : MClassDef */; -val* var12 /* : MClassType */; -val* var14 /* : MClassType */; -val* var15 /* : MClassDef */; -val* var17 /* : MClassDef */; -val* var18 /* : MModule */; -val* var20 /* : MModule */; -short int var21 /* : Bool */; -val* var22 /* : MSignature */; -val* var_msignature /* var msignature: MSignature */; -short int var23 /* : Bool */; -val* var24 /* : MProperty */; -val* var26 /* : MProperty */; -short int var27 /* : Bool */; -short int var29 /* : Bool */; -short int var30 /* : Bool */; -short int var_ /* var : Bool */; -short int var31 /* : Bool */; -short int var33 /* : Bool */; -val* var34 /* : nullable Object */; -val* var35 /* : MClassDef */; -val* var37 /* : MClassDef */; -val* var38 /* : MClass */; -val* var40 /* : MClass */; -val* var41 /* : MClassType */; -val* var43 /* : MClassType */; -val* var44 /* : RuntimeVariable */; -long var45 /* : Int */; -long var_i /* var i: Int */; -long var46 /* : Int */; -long var_47 /* var : Int */; -short int var48 /* : Bool */; -short int var50 /* : Bool */; -int cltype; -int idtype; -const char* var_class_name; -short int var51 /* : Bool */; -val* var52 /* : Array[MParameter] */; -val* var54 /* : Array[MParameter] */; -val* var55 /* : nullable Object */; -val* var56 /* : MType */; -val* var58 /* : MType */; -val* var_t /* var t: MType */; -long var59 /* : Int */; -long var61 /* : Int */; -short int var62 /* : Bool */; -short int var64 /* : Bool */; -long var65 /* : Int */; -long var66 /* : Int */; -short int var68 /* : Bool */; -int cltype69; -int idtype70; -const char* var_class_name71; -long var72 /* : Int */; -val* var73 /* : nullable Object */; -val* var74 /* : MType */; -val* var76 /* : MType */; -short int var77 /* : Bool */; -short int var79 /* : Bool */; -long var80 /* : Int */; -long var81 /* : Int */; -short int var83 /* : Bool */; -int cltype84; -int idtype85; -const char* var_class_name86; -long var87 /* : Int */; -long var88 /* : Int */; -long var89 /* : Int */; -short int var91 /* : Bool */; -int cltype92; -int idtype93; -const char* var_class_name94; -long var95 /* : Int */; -val* var96 /* : nullable Object */; -val* var97 /* : RuntimeVariable */; -long var98 /* : Int */; -long var99 /* : Int */; -var_m = p0; -var_args = p1; +varonce179 = var180; { -{ /* Inline model#MMethodDef#msignature (var_m) on */ -var2 = var_m->attrs[COLOR_nit__model__MMethodDef___msignature].val; /* _msignature on */ -var = var2; -RET_LABEL1:(void)0; +standard__file___Sys___print(var178, var191); /* Direct call file#Sys#print on */ } +var192 = glob_sys; +if (likely(varonce193!=NULL)) { +var194 = varonce193; +} else { +var195 = "# size of attributes tables"; +var196 = standard___standard__NativeString___to_s_with_length(var195, 27l); +var194 = var196; +varonce193 = var194; } { -{ /* Inline model#MPropDef#mclassdef (var_m) on */ -var5 = var_m->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ -if (unlikely(var5 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2010); -show_backtrace(1); +standard__file___Sys___print(var192, var194); /* Direct call file#Sys#print on */ } -var3 = var5; -RET_LABEL4:(void)0; +var197 = glob_sys; +if (likely(varonce198!=NULL)) { +var199 = varonce198; +} else { +var200 = "\ttotal \tholes"; +var201 = standard___standard__NativeString___to_s_with_length(var200, 13l); +var199 = var201; +varonce198 = var199; } +{ +standard__file___Sys___print(var197, var199); /* Direct call file#Sys#print on */ } +var_total = 0l; +var_holes = 0l; { -{ /* Inline model#MClassDef#bound_mtype (var3) on */ -var8 = var3->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ -if (unlikely(var8 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 495); -show_backtrace(1); +{ /* Inline separate_compiler#SeparateCompiler#attr_tables (self) on */ +var204 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___attr_tables].val; /* _attr_tables on */ +if (unlikely(var204 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _attr_tables"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 1054); +fatal_exit(1); } -var6 = var8; -RET_LABEL7:(void)0; +var202 = var204; +RET_LABEL203:(void)0; } } +var_205 = var202; { -{ /* Inline model#MPropDef#mclassdef (var_m) on */ -var11 = var_m->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ -if (unlikely(var11 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2010); -show_backtrace(1); +var206 = ((val*(*)(val* self))((((long)var_205&3)?class_info[((long)var_205&3)]:var_205->class)->vft[COLOR_standard__abstract_collection__MapRead__iterator]))(var_205); /* iterator on */ } -var9 = var11; -RET_LABEL10:(void)0; +var_207 = var206; +for(;;) { +{ +var208 = ((short int(*)(val* self))((((long)var_207&3)?class_info[((long)var_207&3)]:var_207->class)->vft[COLOR_standard__abstract_collection__MapIterator__is_ok]))(var_207); /* is_ok on */ } +if (var208){ +{ +var209 = ((val*(*)(val* self))((((long)var_207&3)?class_info[((long)var_207&3)]:var_207->class)->vft[COLOR_standard__abstract_collection__MapIterator__key]))(var_207); /* key on */ } +var_t210 = var209; { -{ /* Inline model#MClassDef#bound_mtype (var9) on */ -var14 = var9->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ -if (unlikely(var14 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 495); -show_backtrace(1); +var211 = ((val*(*)(val* self))((((long)var_207&3)?class_info[((long)var_207&3)]:var_207->class)->vft[COLOR_standard__abstract_collection__MapIterator__item]))(var_207); /* item on */ } -var12 = var14; -RET_LABEL13:(void)0; +var_table212 = var211; +{ +{ /* Inline array#AbstractArrayRead#length (var_table212) on */ +var215 = var_table212->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on */ +var213 = var215; +RET_LABEL214:(void)0; } } { -{ /* Inline model#MPropDef#mclassdef (var_m) on */ -var17 = var_m->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ -if (unlikely(var17 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2010); -show_backtrace(1); +{ /* Inline kernel#Int#+ (var_total,var213) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var218 = 1; /* easy isa OTHER*/ +if (unlikely(!var218)) { +var_class_name221 = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name221); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 537); +fatal_exit(1); } -var15 = var17; -RET_LABEL16:(void)0; +var222 = var_total + var213; +var216 = var222; +goto RET_LABEL217; +RET_LABEL217:(void)0; } } +var_total = var216; +var_223 = var_table212; { -{ /* Inline model#MClassDef#mmodule (var15) on */ -var20 = var15->attrs[COLOR_nit__model__MClassDef___mmodule].val; /* _mmodule on */ -if (unlikely(var20 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mmodule"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 489); -show_backtrace(1); +var224 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_223); } -var18 = var20; -RET_LABEL19:(void)0; +var_225 = var224; +for(;;) { +{ +var226 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_225); } +if (var226){ +{ +var227 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_225); } -var21 = 1; -if (var == NULL) { -PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 976); -show_backtrace(1); +var_e228 = var227; +if (var_e228 == NULL) { +var229 = 1; /* is null */ } else { -var22 = nit___nit__MSignature___MType__resolve_for(var, var6, var12, var18, var21); +var229 = 0; /* arg is null but recv is not */ } -var_msignature = var22; +if (0) { +{ /* Inline kernel#Object#== (var_e228,((val*)NULL)) on */ +var_other = ((val*)NULL); { -{ /* Inline model#MPropDef#mproperty (var_m) on */ -var26 = var_m->attrs[COLOR_nit__model__MPropDef___mproperty].val; /* _mproperty on */ -if (unlikely(var26 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mproperty"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2013); -show_backtrace(1); +{ /* Inline kernel#Object#is_same_instance (var_e228,var_other) on */ +var234 = var_e228 == var_other; +var232 = var234; +goto RET_LABEL233; +RET_LABEL233:(void)0; } -var24 = var26; -RET_LABEL25:(void)0; } +var230 = var232; +goto RET_LABEL231; +RET_LABEL231:(void)0; +} +var229 = var230; } +if (var229){ { -{ /* Inline model#MMethod#is_init (var24) on */ -var29 = var24->attrs[COLOR_nit__model__MMethod___is_init].s; /* _is_init on */ -var27 = var29; -RET_LABEL28:(void)0; +{ /* Inline kernel#Int#+ (var_holes,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var237 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var237)) { +var_class_name240 = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name240); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 537); +fatal_exit(1); } +var241 = var_holes + 1l; +var235 = var241; +goto RET_LABEL236; +RET_LABEL236:(void)0; } -var30 = !var27; -var_ = var30; -if (var30){ -{ -{ /* Inline model#MMethodDef#is_extern (var_m) on */ -var33 = var_m->attrs[COLOR_nit__model__MMethodDef___is_extern].s; /* _is_extern on */ -var31 = var33; -RET_LABEL32:(void)0; } +var_holes = var235; +} else { +} +{ +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_225); /* Direct call array#ArrayIterator#next on */ } -var23 = var31; } else { -var23 = var_; +goto BREAK_label242; } -if (var23){ +} +BREAK_label242: (void)0; { -var34 = standard___standard__SequenceRead___Collection__first(var_args); +standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__finish(var_225); /* Direct call array#ArrayIterator#finish on */ } { -{ /* Inline model#MPropDef#mclassdef (var_m) on */ -var37 = var_m->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ -if (unlikely(var37 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2010); -show_backtrace(1); +((void(*)(val* self))((((long)var_207&3)?class_info[((long)var_207&3)]:var_207->class)->vft[COLOR_standard__abstract_collection__MapIterator__next]))(var_207); /* next on */ } -var35 = var37; -RET_LABEL36:(void)0; +} else { +goto BREAK_label243; } } +BREAK_label243: (void)0; { -{ /* Inline model#MClassDef#mclass (var35) on */ -var40 = var35->attrs[COLOR_nit__model__MClassDef___mclass].val; /* _mclass on */ -if (unlikely(var40 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 492); -show_backtrace(1); +{ /* Inline abstract_collection#MapIterator#finish (var_207) on */ +RET_LABEL244:(void)0; } -var38 = var40; -RET_LABEL39:(void)0; } +var245 = glob_sys; +if (unlikely(varonce246==NULL)) { +var247 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce248!=NULL)) { +var249 = varonce248; +} else { +var250 = "\t"; +var251 = standard___standard__NativeString___to_s_with_length(var250, 1l); +var249 = var251; +varonce248 = var249; } -{ -{ /* Inline model#MClass#mclass_type (var38) on */ -var43 = var38->attrs[COLOR_nit__model__MClass___mclass_type].val; /* _mclass_type on */ -if (unlikely(var43 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass_type"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 438); -show_backtrace(1); +((struct instance_standard__NativeArray*)var247)->values[0]=var249; +if (likely(varonce252!=NULL)) { +var253 = varonce252; +} else { +var254 = "\t"; +var255 = standard___standard__NativeString___to_s_with_length(var254, 1l); +var253 = var255; +varonce252 = var253; } -var41 = var43; -RET_LABEL42:(void)0; +((struct instance_standard__NativeArray*)var247)->values[2]=var253; +} else { +var247 = varonce246; +varonce246 = NULL; } +var256 = standard__string___Int___Object__to_s(var_total); +((struct instance_standard__NativeArray*)var247)->values[1]=var256; +var257 = standard__string___Int___Object__to_s(var_holes); +((struct instance_standard__NativeArray*)var247)->values[3]=var257; +{ +var258 = ((val*(*)(val* self))(var247->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var247); /* native_to_s on */ } +varonce246 = var247; { -var44 = ((val* (*)(val* self, val* p0, val* p1))(self->class->vft[COLOR_nit__abstract_compiler__AbstractCompilerVisitor__unbox_extern]))(self, var34, var41) /* unbox_extern on */; +standard__file___Sys___print(var245, var258); /* Direct call file#Sys#print on */ +} +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#isset_checks_count for (self: SeparateCompiler): Int */ +long nit___nit__SeparateCompiler___isset_checks_count(val* self) { +long var /* : Int */; +long var1 /* : Int */; +var1 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___isset_checks_count].l; /* _isset_checks_count on */ +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#isset_checks_count= for (self: SeparateCompiler, Int) */ +void nit___nit__SeparateCompiler___isset_checks_count_61d(val* self, long p0) { +self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___isset_checks_count].l = p0; /* _isset_checks_count on */ +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#attr_read_count for (self: SeparateCompiler): Int */ +long nit___nit__SeparateCompiler___attr_read_count(val* self) { +long var /* : Int */; +long var1 /* : Int */; +var1 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___attr_read_count].l; /* _attr_read_count on */ +var = var1; +RET_LABEL:; +return var; +} +/* method separate_compiler#SeparateCompiler#attr_read_count= for (self: SeparateCompiler, Int) */ +void nit___nit__SeparateCompiler___attr_read_count_61d(val* self, long p0) { +self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___attr_read_count].l = p0; /* _attr_read_count on */ +RET_LABEL:; +} +/* method separate_compiler#SeparateCompiler#display_isset_checks for (self: SeparateCompiler) */ +void nit___nit__SeparateCompiler___display_isset_checks(val* self) { +val* var /* : Sys */; +static val* varonce; +val* var1 /* : String */; +char* var2 /* : NativeString */; +val* var3 /* : FlatString */; +val* var4 /* : Sys */; +val* var6 /* : NativeArray[String] */; +static val* varonce5; +static val* varonce7; +val* var8 /* : String */; +char* var9 /* : NativeString */; +val* var10 /* : FlatString */; +long var11 /* : Int */; +long var13 /* : Int */; +val* var14 /* : String */; +val* var15 /* : String */; +val* var16 /* : Sys */; +static val* varonce17; +val* var18 /* : String */; +char* var19 /* : NativeString */; +val* var20 /* : FlatString */; +val* var21 /* : Sys */; +val* var23 /* : NativeArray[String] */; +static val* varonce22; +static val* varonce24; +val* var25 /* : String */; +char* var26 /* : NativeString */; +val* var27 /* : FlatString */; +long var28 /* : Int */; +long var30 /* : Int */; +val* var31 /* : String */; +val* var32 /* : String */; +var = glob_sys; +if (likely(varonce!=NULL)) { +var1 = varonce; +} else { +var2 = "# total number of compiled attribute reads"; +var3 = standard___standard__NativeString___to_s_with_length(var2, 42l); +var1 = var3; +varonce = var1; } { -standard___standard__Sequence___first_61d(var_args, var44); /* Direct call abstract_collection#Sequence#first= on */ +standard__file___Sys___print(var, var1); /* Direct call file#Sys#print on */ } +var4 = glob_sys; +if (unlikely(varonce5==NULL)) { +var6 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce7!=NULL)) { +var8 = varonce7; } else { +var9 = "\t"; +var10 = standard___standard__NativeString___to_s_with_length(var9, 1l); +var8 = var10; +varonce7 = var8; } -var45 = 0; -var_i = var45; -{ -var46 = nit___nit__MSignature___arity(var_msignature); +((struct instance_standard__NativeArray*)var6)->values[0]=var8; +} else { +var6 = varonce5; +varonce5 = NULL; } -var_47 = var46; -for(;;) { { -{ /* Inline kernel#Int#< (var_i,var_47) on */ -/* Covariant cast for argument 0 (i) isa OTHER */ -/* isa OTHER */ -var50 = 1; /* easy isa OTHER*/ -if (unlikely(!var50)) { -var_class_name = type_standard__Int.name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); -PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 410); -show_backtrace(1); -} -var51 = var_i < var_47; -var48 = var51; -goto RET_LABEL49; -RET_LABEL49:(void)0; +{ /* Inline separate_compiler#SeparateCompiler#attr_read_count (self) on */ +var13 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___attr_read_count].l; /* _attr_read_count on */ +var11 = var13; +RET_LABEL12:(void)0; } } -if (var48){ +var14 = standard__string___Int___Object__to_s(var11); +((struct instance_standard__NativeArray*)var6)->values[1]=var14; { -{ /* Inline model#MSignature#mparameters (var_msignature) on */ -var54 = var_msignature->attrs[COLOR_nit__model__MSignature___mparameters].val; /* _mparameters on */ -if (unlikely(var54 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mparameters"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1592); -show_backtrace(1); -} -var52 = var54; -RET_LABEL53:(void)0; -} +var15 = ((val*(*)(val* self))(var6->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var6); /* native_to_s on */ } +varonce5 = var6; { -var55 = standard___standard__Array___standard__abstract_collection__SequenceRead___91d_93d(var52, var_i); +standard__file___Sys___print(var4, var15); /* Direct call file#Sys#print on */ +} +var16 = glob_sys; +if (likely(varonce17!=NULL)) { +var18 = varonce17; +} else { +var19 = "# total number of compiled isset-checks"; +var20 = standard___standard__NativeString___to_s_with_length(var19, 39l); +var18 = var20; +varonce17 = var18; } { -{ /* Inline model#MParameter#mtype (var55) on */ -var58 = var55->attrs[COLOR_nit__model__MParameter___mtype].val; /* _mtype on */ -if (unlikely(var58 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1690); -show_backtrace(1); +standard__file___Sys___print(var16, var18); /* Direct call file#Sys#print on */ } -var56 = var58; -RET_LABEL57:(void)0; +var21 = glob_sys; +if (unlikely(varonce22==NULL)) { +var23 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce24!=NULL)) { +var25 = varonce24; +} else { +var26 = "\t"; +var27 = standard___standard__NativeString___to_s_with_length(var26, 1l); +var25 = var27; +varonce24 = var25; } +((struct instance_standard__NativeArray*)var23)->values[0]=var25; +} else { +var23 = varonce22; +varonce22 = NULL; } -var_t = var56; { -{ /* Inline model#MSignature#vararg_rank (var_msignature) on */ -var61 = var_msignature->attrs[COLOR_nit__model__MSignature___vararg_rank].l; /* _vararg_rank on */ -var59 = var61; -RET_LABEL60:(void)0; +{ /* Inline separate_compiler#SeparateCompiler#isset_checks_count (self) on */ +var30 = self->attrs[COLOR_nit__separate_compiler__SeparateCompiler___isset_checks_count].l; /* _isset_checks_count on */ +var28 = var30; +RET_LABEL29:(void)0; } } +var31 = standard__string___Int___Object__to_s(var28); +((struct instance_standard__NativeArray*)var23)->values[1]=var31; { -{ /* Inline kernel#Int#== (var_i,var59) on */ -var64 = var_i == var59; -var62 = var64; -goto RET_LABEL63; -RET_LABEL63:(void)0; -} +var32 = ((val*(*)(val* self))(var23->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var23); /* native_to_s on */ } -if (var62){ -var65 = 1; +varonce22 = var23; { -{ /* Inline kernel#Int#+ (var_i,var65) on */ -/* Covariant cast for argument 0 (i) isa OTHER */ -/* isa OTHER */ -var68 = 1; /* easy isa OTHER*/ -if (unlikely(!var68)) { -var_class_name71 = type_standard__Int.name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name71); -PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413); -show_backtrace(1); +standard__file___Sys___print(var21, var32); /* Direct call file#Sys#print on */ } -var72 = var_i + var65; -var66 = var72; -goto RET_LABEL67; -RET_LABEL67:(void)0; -} -} -{ -var73 = standard___standard__Array___standard__abstract_collection__SequenceRead___91d_93d(var_args, var66); +RET_LABEL:; } +/* method separate_compiler#SeparateCompiler#compile_nitni_structs for (self: SeparateCompiler) */ +void nit___nit__SeparateCompiler___nit__abstract_compiler__AbstractCompiler__compile_nitni_structs(val* self) { +val* var /* : CodeWriter */; +val* var2 /* : CodeWriter */; +static val* varonce; +val* var3 /* : String */; +char* var4 /* : NativeString */; +val* var5 /* : FlatString */; { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var73) on */ -var76 = var73->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var76 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); +{ /* Inline abstract_compiler#AbstractCompiler#header (self) on */ +var2 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___header].val; /* _header on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _header"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 569); +fatal_exit(1); } -var74 = var76; -RET_LABEL75:(void)0; +var = var2; +RET_LABEL1:(void)0; } } -var_t = var74; +if (likely(varonce!=NULL)) { +var3 = varonce; } else { +var4 = "struct nitni_instance {\n\tstruct nitni_instance *next,\n\t\t*prev; /* adjacent global references in global list */\n\tint count; /* number of time this global reference has been marked */\n\tstruct instance *value;\n};\n"; +var5 = standard___standard__NativeString___to_s_with_length(var4, 210l); +var3 = var5; +varonce = var3; } { -{ /* Inline model#MMethodDef#is_extern (var_m) on */ -var79 = var_m->attrs[COLOR_nit__model__MMethodDef___is_extern].s; /* _is_extern on */ -var77 = var79; -RET_LABEL78:(void)0; -} +nit___nit__CodeWriter___add_decl(var, var3); /* Direct call abstract_compiler#CodeWriter#add_decl on */ } -if (var77){ -var80 = 1; { -{ /* Inline kernel#Int#+ (var_i,var80) on */ -/* Covariant cast for argument 0 (i) isa OTHER */ -/* isa OTHER */ -var83 = 1; /* easy isa OTHER*/ -if (unlikely(!var83)) { -var_class_name86 = type_standard__Int.name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name86); -PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413); -show_backtrace(1); -} -var87 = var_i + var80; -var81 = var87; -goto RET_LABEL82; -RET_LABEL82:(void)0; +((void(*)(val* self))(self->class->vft[COLOR_nit___nit__SeparateCompiler___nit__abstract_compiler__AbstractCompiler__compile_nitni_structs]))(self); /* compile_nitni_structs on */ } +RET_LABEL:; } -var88 = 1; +/* method separate_compiler#SeparateCompiler#finalize_ffi_for_module for (self: SeparateCompiler, MModule) */ +void nit___nit__SeparateCompiler___nit__abstract_compiler__AbstractCompiler__finalize_ffi_for_module(val* self, val* p0) { +val* var_mmodule /* var mmodule: MModule */; +val* var /* : MModule */; +val* var2 /* : MModule */; +val* var_old_module /* var old_module: MModule */; +var_mmodule = p0; { -{ /* Inline kernel#Int#+ (var_i,var88) on */ -/* Covariant cast for argument 0 (i) isa OTHER */ -/* isa OTHER */ -var91 = 1; /* easy isa OTHER*/ -if (unlikely(!var91)) { -var_class_name94 = type_standard__Int.name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name94); -PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413); -show_backtrace(1); +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (self) on */ +var2 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ +if (unlikely(var2 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 515); +fatal_exit(1); } -var95 = var_i + var88; -var89 = var95; -goto RET_LABEL90; -RET_LABEL90:(void)0; +var = var2; +RET_LABEL1:(void)0; } } +var_old_module = var; { -var96 = standard___standard__Array___standard__abstract_collection__SequenceRead___91d_93d(var_args, var89); +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule= (self,var_mmodule) on */ +self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val = var_mmodule; /* _mainmodule on */ +RET_LABEL3:(void)0; } -{ -var97 = ((val* (*)(val* self, val* p0, val* p1))(self->class->vft[COLOR_nit__abstract_compiler__AbstractCompilerVisitor__unbox_extern]))(self, var96, var_t) /* unbox_extern on */; } { -standard___standard__Array___standard__abstract_collection__Sequence___91d_93d_61d(var_args, var81, var97); /* Direct call array#Array#[]= on */ -} -} else { +((void(*)(val* self, val* p0))(self->class->vft[COLOR_nit___nit__SeparateCompiler___nit__abstract_compiler__AbstractCompiler__finalize_ffi_for_module]))(self, p0); /* finalize_ffi_for_module on */ } -var98 = 1; { -var99 = standard___standard__Int___Discrete__successor(var_i, var98); -} -var_i = var99; -} else { -goto BREAK_label; +{ /* Inline abstract_compiler#AbstractCompiler#mainmodule= (self,var_old_module) on */ +self->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val = var_old_module; /* _mainmodule on */ +RET_LABEL4:(void)0; } } -BREAK_label: (void)0; RET_LABEL:; } -/* method separate_compiler#SeparateCompilerVisitor#autobox for (self: SeparateCompilerVisitor, RuntimeVariable, MType): RuntimeVariable */ -val* nit___nit__SeparateCompilerVisitor___nit__abstract_compiler__AbstractCompilerVisitor__autobox(val* self, val* p0, val* p1) { -val* var /* : RuntimeVariable */; -val* var_value /* var value: RuntimeVariable */; -val* var_mtype /* var mtype: MType */; -val* var1 /* : MType */; -val* var3 /* : MType */; -short int var4 /* : Bool */; +/* method separate_compiler#SeparateCompilerVisitor#adapt_signature for (self: SeparateCompilerVisitor, MMethodDef, Array[RuntimeVariable]) */ +void nit___nit__SeparateCompilerVisitor___nit__abstract_compiler__AbstractCompilerVisitor__adapt_signature(val* self, val* p0, val* p1) { +val* var_m /* var m: MMethodDef */; +val* var_args /* var args: Array[RuntimeVariable] */; +val* var /* : nullable MSignature */; +val* var2 /* : nullable MSignature */; +val* var3 /* : MClassDef */; +val* var5 /* : MClassDef */; +val* var6 /* : MClassType */; +val* var8 /* : MClassType */; +val* var9 /* : MClassDef */; +val* var11 /* : MClassDef */; +val* var12 /* : MClassType */; +val* var14 /* : MClassType */; +val* var15 /* : MClassDef */; +val* var17 /* : MClassDef */; +val* var18 /* : MModule */; +val* var20 /* : MModule */; +val* var21 /* : MSignature */; +val* var_msignature /* var msignature: MSignature */; +val* var22 /* : nullable Object */; +val* var_recv /* var recv: RuntimeVariable */; +val* var23 /* : MType */; +val* var25 /* : MType */; +val* var26 /* : String */; +val* var27 /* : MClassDef */; +val* var29 /* : MClassDef */; +val* var30 /* : MClass */; +val* var32 /* : MClass */; +val* var33 /* : MClassType */; +val* var35 /* : MClassType */; +val* var36 /* : String */; +short int var37 /* : Bool */; val* var_other /* var other: nullable Object */; -short int var6 /* : Bool */; -short int var8 /* : Bool */; -short int var9 /* : Bool */; -val* var10 /* : MType */; -val* var12 /* : MType */; -val* var13 /* : String */; -static val* varonce; -val* var14 /* : String */; -char* var15 /* : NativeString */; -long var16 /* : Int */; -val* var17 /* : FlatString */; -short int var18 /* : Bool */; -short int var_ /* var : Bool */; -val* var19 /* : String */; -static val* varonce20; -val* var21 /* : String */; -char* var22 /* : NativeString */; -long var23 /* : Int */; -val* var24 /* : FlatString */; -short int var25 /* : Bool */; -val* var26 /* : MType */; -val* var28 /* : MType */; -val* var29 /* : String */; -static val* varonce30; -val* var31 /* : String */; -char* var32 /* : NativeString */; -long var33 /* : Int */; -val* var34 /* : FlatString */; -short int var35 /* : Bool */; -static val* varonce36; -val* var37 /* : String */; -char* var38 /* : NativeString */; -long var39 /* : Int */; -val* var40 /* : FlatString */; -val* var41 /* : String */; -static val* varonce42; -val* var43 /* : String */; -char* var44 /* : NativeString */; -long var45 /* : Int */; -val* var46 /* : FlatString */; -static val* varonce47; -val* var48 /* : String */; -char* var49 /* : NativeString */; -long var50 /* : Int */; -val* var51 /* : FlatString */; -val* var52 /* : MType */; -val* var54 /* : MType */; -static val* varonce55; -val* var56 /* : String */; -char* var57 /* : NativeString */; -long var58 /* : Int */; -val* var59 /* : FlatString */; -static val* varonce60; -val* var61 /* : String */; -char* var62 /* : NativeString */; -long var63 /* : Int */; -val* var64 /* : FlatString */; -val* var65 /* : Array[Object] */; -long var66 /* : Int */; -val* var67 /* : NativeArray[Object] */; -val* var68 /* : String */; -val* var69 /* : RuntimeVariable */; -val* var70 /* : String */; -static val* varonce71; -val* var72 /* : String */; -char* var73 /* : NativeString */; -long var74 /* : Int */; -val* var75 /* : FlatString */; -short int var76 /* : Bool */; -val* var77 /* : MType */; -val* var79 /* : MType */; -short int var80 /* : Bool */; +short int var39 /* : Bool */; +short int var40 /* : Bool */; +val* var41 /* : nullable Object */; +val* var42 /* : MClassDef */; +val* var44 /* : MClassDef */; +val* var45 /* : MClass */; +val* var47 /* : MClass */; +val* var48 /* : MClassType */; +val* var50 /* : MClassType */; +val* var51 /* : RuntimeVariable */; +long var_i /* var i: Int */; +long var52 /* : Int */; +long var_ /* var : Int */; +short int var53 /* : Bool */; +short int var55 /* : Bool */; int cltype; int idtype; const char* var_class_name; -val* var_valtype /* var valtype: MClassType */; -short int var81 /* : Bool */; -short int var82 /* : Bool */; +short int var56 /* : Bool */; +val* var57 /* : Array[MParameter] */; +val* var59 /* : Array[MParameter] */; +val* var60 /* : nullable Object */; +val* var61 /* : MType */; +val* var63 /* : MType */; +val* var_t /* var t: MType */; +long var64 /* : Int */; +long var66 /* : Int */; +short int var67 /* : Bool */; +short int var69 /* : Bool */; +long var70 /* : Int */; +short int var72 /* : Bool */; +int cltype73; +int idtype74; +const char* var_class_name75; +long var76 /* : Int */; +val* var77 /* : nullable Object */; +val* var78 /* : MType */; +val* var80 /* : MType */; +long var81 /* : Int */; short int var83 /* : Bool */; int cltype84; int idtype85; -short int var_86 /* var : Bool */; -val* var87 /* : MClass */; -val* var89 /* : MClass */; -val* var90 /* : MClassKind */; -val* var92 /* : MClassKind */; -val* var93 /* : MClassKind */; -short int var94 /* : Bool */; -short int var96 /* : Bool */; -short int var98 /* : Bool */; -short int var_99 /* var : Bool */; -val* var100 /* : MClass */; -val* var102 /* : MClass */; -val* var103 /* : String */; -val* var105 /* : String */; -static val* varonce106; -val* var107 /* : String */; -char* var108 /* : NativeString */; -long var109 /* : Int */; -val* var110 /* : FlatString */; -short int var111 /* : Bool */; -val* var_other113 /* var other: nullable Object */; -short int var114 /* : Bool */; -short int var115 /* : Bool */; -val* var116 /* : AbstractCompiler */; -val* var118 /* : AbstractCompiler */; -val* var119 /* : MModule */; -val* var121 /* : MModule */; -val* var122 /* : MClassType */; -val* var123 /* : RuntimeVariable */; -val* var_res /* var res: RuntimeVariable */; -short int var124 /* : Bool */; -val* var125 /* : AbstractCompiler */; -val* var127 /* : AbstractCompiler */; -val* var128 /* : nullable RapidTypeAnalysis */; -val* var130 /* : nullable RapidTypeAnalysis */; -val* var131 /* : null */; -short int var132 /* : Bool */; -short int var133 /* : Bool */; -short int var135 /* : Bool */; -short int var136 /* : Bool */; -short int var_137 /* var : Bool */; -val* var138 /* : AbstractCompiler */; -val* var140 /* : AbstractCompiler */; -val* var141 /* : nullable RapidTypeAnalysis */; -val* var143 /* : nullable RapidTypeAnalysis */; -val* var144 /* : HashSet[MClassType] */; -val* var146 /* : HashSet[MClassType] */; -short int var147 /* : Bool */; -short int var148 /* : Bool */; -static val* varonce149; -val* var150 /* : String */; -char* var151 /* : NativeString */; -long var152 /* : Int */; -val* var153 /* : FlatString */; -val* var154 /* : MType */; -val* var156 /* : MType */; -static val* varonce157; -val* var158 /* : String */; -char* var159 /* : NativeString */; -long var160 /* : Int */; -val* var161 /* : FlatString */; -static val* varonce162; -val* var163 /* : String */; -char* var164 /* : NativeString */; -long var165 /* : Int */; -val* var166 /* : FlatString */; -val* var167 /* : MType */; -val* var169 /* : MType */; -static val* varonce170; -val* var171 /* : String */; -char* var172 /* : NativeString */; -long var173 /* : Int */; -val* var174 /* : FlatString */; -val* var175 /* : Array[Object] */; -long var176 /* : Int */; -val* var177 /* : NativeArray[Object] */; -val* var178 /* : String */; -static val* varonce179; -val* var180 /* : String */; -char* var181 /* : NativeString */; -long var182 /* : Int */; -val* var183 /* : FlatString */; -static val* varonce184; -val* var185 /* : String */; -char* var186 /* : NativeString */; -long var187 /* : Int */; -val* var188 /* : FlatString */; -val* var189 /* : String */; -val* var190 /* : Array[Object] */; -long var191 /* : Int */; -val* var192 /* : NativeArray[Object] */; -val* var193 /* : String */; -static val* varonce194; -val* var195 /* : String */; -char* var196 /* : NativeString */; -long var197 /* : Int */; -val* var198 /* : FlatString */; -val* var199 /* : String */; -static val* varonce200; -val* var201 /* : String */; -char* var202 /* : NativeString */; -long var203 /* : Int */; -val* var204 /* : FlatString */; -static val* varonce205; -val* var206 /* : String */; -char* var207 /* : NativeString */; -long var208 /* : Int */; -val* var209 /* : FlatString */; -val* var210 /* : MType */; -val* var212 /* : MType */; -static val* varonce213; -val* var214 /* : String */; -char* var215 /* : NativeString */; -long var216 /* : Int */; -val* var217 /* : FlatString */; -static val* varonce218; -val* var219 /* : String */; -char* var220 /* : NativeString */; -long var221 /* : Int */; -val* var222 /* : FlatString */; -val* var223 /* : Array[Object] */; -long var224 /* : Int */; -val* var225 /* : NativeArray[Object] */; -val* var226 /* : String */; -short int var227 /* : Bool */; -short int var228 /* : Bool */; -short int var229 /* : Bool */; -val* var230 /* : MType */; -val* var232 /* : MType */; -val* var233 /* : String */; -static val* varonce234; -val* var235 /* : String */; -char* var236 /* : NativeString */; -long var237 /* : Int */; -val* var238 /* : FlatString */; -short int var239 /* : Bool */; -short int var_240 /* var : Bool */; -val* var241 /* : String */; -static val* varonce242; -val* var243 /* : String */; -char* var244 /* : NativeString */; -long var245 /* : Int */; -val* var246 /* : FlatString */; -short int var247 /* : Bool */; -short int var_248 /* var : Bool */; -short int var249 /* : Bool */; -val* var250 /* : MType */; -val* var252 /* : MType */; -val* var253 /* : String */; -static val* varonce254; -val* var255 /* : String */; -char* var256 /* : NativeString */; -long var257 /* : Int */; -val* var258 /* : FlatString */; -short int var259 /* : Bool */; -short int var_260 /* var : Bool */; -val* var261 /* : String */; -static val* varonce262; -val* var263 /* : String */; -char* var264 /* : NativeString */; -long var265 /* : Int */; -val* var266 /* : FlatString */; -short int var267 /* : Bool */; -short int var_268 /* var : Bool */; -short int var269 /* : Bool */; -val* var270 /* : MType */; -val* var272 /* : MType */; -val* var273 /* : String */; -static val* varonce274; -val* var275 /* : String */; -char* var276 /* : NativeString */; -long var277 /* : Int */; -val* var278 /* : FlatString */; -short int var279 /* : Bool */; -short int var_280 /* var : Bool */; -val* var281 /* : String */; -static val* varonce282; -val* var283 /* : String */; -char* var284 /* : NativeString */; -long var285 /* : Int */; -val* var286 /* : FlatString */; -short int var287 /* : Bool */; -val* var288 /* : RuntimeVariable */; -val* var_res289 /* var res: RuntimeVariable */; -static val* varonce290; -val* var291 /* : String */; -char* var292 /* : NativeString */; -long var293 /* : Int */; -val* var294 /* : FlatString */; -static val* varonce295; -val* var296 /* : String */; -char* var297 /* : NativeString */; -long var298 /* : Int */; -val* var299 /* : FlatString */; -val* var300 /* : MType */; -val* var302 /* : MType */; -static val* varonce303; -val* var304 /* : String */; -char* var305 /* : NativeString */; -long var306 /* : Int */; -val* var307 /* : FlatString */; -static val* varonce308; -val* var309 /* : String */; -char* var310 /* : NativeString */; -long var311 /* : Int */; -val* var312 /* : FlatString */; -val* var313 /* : Array[Object] */; -long var314 /* : Int */; -val* var315 /* : NativeArray[Object] */; -val* var316 /* : String */; -static val* varonce317; -val* var318 /* : String */; -char* var319 /* : NativeString */; -long var320 /* : Int */; -val* var321 /* : FlatString */; -val* var322 /* : MType */; -val* var324 /* : MType */; -static val* varonce325; -val* var326 /* : String */; -char* var327 /* : NativeString */; -long var328 /* : Int */; -val* var329 /* : FlatString */; -static val* varonce330; -val* var331 /* : String */; -char* var332 /* : NativeString */; -long var333 /* : Int */; -val* var334 /* : FlatString */; -val* var335 /* : Array[Object] */; -long var336 /* : Int */; -val* var337 /* : NativeArray[Object] */; -val* var338 /* : String */; -var_value = p0; -var_mtype = p1; -{ -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var3 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var3 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); -} -var1 = var3; -RET_LABEL2:(void)0; -} -} -{ -{ /* Inline kernel#Object#== (var1,var_mtype) on */ -var_other = var_mtype; -{ -{ /* Inline kernel#Object#is_same_instance (var1,var_other) on */ -var8 = var1 == var_other; -var6 = var8; -goto RET_LABEL7; -RET_LABEL7:(void)0; -} -} -var4 = var6; -goto RET_LABEL5; -RET_LABEL5:(void)0; -} -} -if (var4){ -var = var_value; -goto RET_LABEL; -} else { +const char* var_class_name86; +long var87 /* : Int */; +long var88 /* : Int */; +short int var90 /* : Bool */; +int cltype91; +int idtype92; +const char* var_class_name93; +long var94 /* : Int */; +val* var95 /* : nullable Object */; +val* var96 /* : RuntimeVariable */; +long var97 /* : Int */; +var_m = p0; +var_args = p1; { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var12 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var12 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); -} -var10 = var12; -RET_LABEL11:(void)0; +{ /* Inline model#MMethodDef#msignature (var_m) on */ +var2 = var_m->attrs[COLOR_nit__model__MMethodDef___msignature].val; /* _msignature on */ +var = var2; +RET_LABEL1:(void)0; } } { -var13 = ((val* (*)(val* self))(var10->class->vft[COLOR_nit__abstract_compiler__MType__ctype]))(var10) /* ctype on */; +{ /* Inline model#MPropDef#mclassdef (var_m) on */ +var5 = var_m->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var5 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2209); +fatal_exit(1); } -if (varonce) { -var14 = varonce; -} else { -var15 = "val*"; -var16 = 4; -var17 = standard___standard__NativeString___to_s_with_length(var15, var16); -var14 = var17; -varonce = var14; +var3 = var5; +RET_LABEL4:(void)0; } -{ -var18 = ((short int (*)(val* self, val* p0))(var13->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var13, var14) /* == on */; } -var_ = var18; -if (var18){ { -var19 = ((val* (*)(val* self))(var_mtype->class->vft[COLOR_nit__abstract_compiler__MType__ctype]))(var_mtype) /* ctype on */; -} -if (varonce20) { -var21 = varonce20; -} else { -var22 = "val*"; -var23 = 4; -var24 = standard___standard__NativeString___to_s_with_length(var22, var23); -var21 = var24; -varonce20 = var21; +{ /* Inline model#MClassDef#bound_mtype (var3) on */ +var8 = var3->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ +if (unlikely(var8 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 556); +fatal_exit(1); } -{ -var25 = ((short int (*)(val* self, val* p0))(var19->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var19, var21) /* == on */; +var6 = var8; +RET_LABEL7:(void)0; } -var9 = var25; -} else { -var9 = var_; } -if (var9){ -var = var_value; -goto RET_LABEL; -} else { { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var28 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var28 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); +{ /* Inline model#MPropDef#mclassdef (var_m) on */ +var11 = var_m->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var11 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2209); +fatal_exit(1); } -var26 = var28; -RET_LABEL27:(void)0; +var9 = var11; +RET_LABEL10:(void)0; } } { -var29 = ((val* (*)(val* self))(var26->class->vft[COLOR_nit__abstract_compiler__MType__ctype]))(var26) /* ctype on */; -} -if (varonce30) { -var31 = varonce30; -} else { -var32 = "val*"; -var33 = 4; -var34 = standard___standard__NativeString___to_s_with_length(var32, var33); -var31 = var34; -varonce30 = var31; +{ /* Inline model#MClassDef#bound_mtype (var9) on */ +var14 = var9->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ +if (unlikely(var14 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 556); +fatal_exit(1); } -{ -var35 = ((short int (*)(val* self, val* p0))(var29->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var29, var31) /* == on */; +var12 = var14; +RET_LABEL13:(void)0; } -if (var35){ -if (varonce36) { -var37 = varonce36; -} else { -var38 = "((struct instance_"; -var39 = 18; -var40 = standard___standard__NativeString___to_s_with_length(var38, var39); -var37 = var40; -varonce36 = var37; } { -var41 = ((val* (*)(val* self))(var_mtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_mtype) /* c_name on */; +{ /* Inline model#MPropDef#mclassdef (var_m) on */ +var17 = var_m->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var17 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2209); +fatal_exit(1); } -if (varonce42) { -var43 = varonce42; -} else { -var44 = "*)"; -var45 = 2; -var46 = standard___standard__NativeString___to_s_with_length(var44, var45); -var43 = var46; -varonce42 = var43; +var15 = var17; +RET_LABEL16:(void)0; } -if (varonce47) { -var48 = varonce47; -} else { -var49 = ")->value; /* autounbox from "; -var50 = 28; -var51 = standard___standard__NativeString___to_s_with_length(var49, var50); -var48 = var51; -varonce47 = var48; } { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var54 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var54 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); -} -var52 = var54; -RET_LABEL53:(void)0; +{ /* Inline model#MClassDef#mmodule (var15) on */ +var20 = var15->attrs[COLOR_nit__model__MClassDef___mmodule].val; /* _mmodule on */ +if (unlikely(var20 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 550); +fatal_exit(1); } +var18 = var20; +RET_LABEL19:(void)0; } -if (varonce55) { -var56 = varonce55; -} else { -var57 = " to "; -var58 = 4; -var59 = standard___standard__NativeString___to_s_with_length(var57, var58); -var56 = var59; -varonce55 = var56; } -if (varonce60) { -var61 = varonce60; +if (var == NULL) { +PRINT_ERROR("Runtime error: %s", "Receiver is null"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 1157); +fatal_exit(1); } else { -var62 = " */"; -var63 = 3; -var64 = standard___standard__NativeString___to_s_with_length(var62, var63); -var61 = var64; -varonce60 = var61; -} -var65 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var65 = array_instance Array[Object] */ -var66 = 9; -var67 = NEW_standard__NativeArray(var66, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var67)->values[0] = (val*) var37; -((struct instance_standard__NativeArray*)var67)->values[1] = (val*) var41; -((struct instance_standard__NativeArray*)var67)->values[2] = (val*) var43; -((struct instance_standard__NativeArray*)var67)->values[3] = (val*) var_value; -((struct instance_standard__NativeArray*)var67)->values[4] = (val*) var48; -((struct instance_standard__NativeArray*)var67)->values[5] = (val*) var52; -((struct instance_standard__NativeArray*)var67)->values[6] = (val*) var56; -((struct instance_standard__NativeArray*)var67)->values[7] = (val*) var_mtype; -((struct instance_standard__NativeArray*)var67)->values[8] = (val*) var61; -{ -((void (*)(val* self, val* p0, long p1))(var65->class->vft[COLOR_standard__array__Array__with_native]))(var65, var67, var66) /* with_native on */; -} +var21 = nit___nit__MSignature___MType__resolve_for(var, var6, var12, var18, 1); } +var_msignature = var21; { -var68 = ((val* (*)(val* self))(var65->class->vft[COLOR_standard__string__Object__to_s]))(var65) /* to_s on */; +var22 = standard___standard__SequenceRead___Collection__first(var_args); } +var_recv = var22; { -var69 = nit___nit__AbstractCompilerVisitor___new_expr(self, var68, var_mtype); +{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_recv) on */ +var25 = var_recv->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var25 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1784); +fatal_exit(1); } -var = var69; -goto RET_LABEL; -} else { -{ -var70 = ((val* (*)(val* self))(var_mtype->class->vft[COLOR_nit__abstract_compiler__MType__ctype]))(var_mtype) /* ctype on */; +var23 = var25; +RET_LABEL24:(void)0; } -if (varonce71) { -var72 = varonce71; -} else { -var73 = "val*"; -var74 = 4; -var75 = standard___standard__NativeString___to_s_with_length(var73, var74); -var72 = var75; -varonce71 = var72; } { -var76 = ((short int (*)(val* self, val* p0))(var70->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var70, var72) /* == on */; +var26 = ((val*(*)(val* self))(var23->class->vft[COLOR_nit__abstract_compiler__MType__ctype]))(var23); /* ctype on */ } -if (var76){ { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var79 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var79 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); -} -var77 = var79; -RET_LABEL78:(void)0; -} -} -/* isa MClassType */ -cltype = type_nit__MClassType.color; -idtype = type_nit__MClassType.id; -if(cltype >= var77->type->table_size) { -var80 = 0; -} else { -var80 = var77->type->type_table[cltype] == idtype; +{ /* Inline model#MPropDef#mclassdef (var_m) on */ +var29 = var_m->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var29 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2209); +fatal_exit(1); } -if (unlikely(!var80)) { -var_class_name = var77 == NULL ? "null" : var77->type->name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 998); -show_backtrace(1); +var27 = var29; +RET_LABEL28:(void)0; } -var_valtype = var77; -/* isa MClassType */ -cltype84 = type_nit__MClassType.color; -idtype85 = type_nit__MClassType.id; -if(cltype84 >= var_mtype->type->table_size) { -var83 = 0; -} else { -var83 = var_mtype->type->type_table[cltype84] == idtype85; } -var_86 = var83; -if (var83){ { -{ /* Inline model#MClassType#mclass (var_mtype) on */ -var89 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var89 == NULL)) { +{ /* Inline model#MClassDef#mclass (var27) on */ +var32 = var27->attrs[COLOR_nit__model__MClassDef___mclass].val; /* _mclass on */ +if (unlikely(var32 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1058); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 553); +fatal_exit(1); } -var87 = var89; -RET_LABEL88:(void)0; +var30 = var32; +RET_LABEL31:(void)0; } } { -{ /* Inline model#MClass#kind (var87) on */ -var92 = var87->attrs[COLOR_nit__model__MClass___kind].val; /* _kind on */ -if (unlikely(var92 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _kind"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 399); -show_backtrace(1); +{ /* Inline model#MClass#mclass_type (var30) on */ +var35 = var30->attrs[COLOR_nit__model__MClass___mclass_type].val; /* _mclass_type on */ +if (unlikely(var35 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass_type"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 484); +fatal_exit(1); } -var90 = var92; -RET_LABEL91:(void)0; +var33 = var35; +RET_LABEL34:(void)0; } } { -var93 = nit__model___standard__Object___extern_kind(self); +var36 = nit__abstract_compiler___MClassType___MType__ctype(var33); } { -{ /* Inline kernel#Object#== (var90,var93) on */ -var_other = var93; +{ /* Inline kernel#Object#!= (var26,var36) on */ +var_other = var36; { -{ /* Inline kernel#Object#is_same_instance (var90,var_other) on */ -var98 = var90 == var_other; -var96 = var98; -goto RET_LABEL97; -RET_LABEL97:(void)0; -} -} -var94 = var96; -goto RET_LABEL95; -RET_LABEL95:(void)0; +var39 = ((short int(*)(val* self, val* p0))(var26->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var26, var_other); /* == on */ } +var40 = !var39; +var37 = var40; +goto RET_LABEL38; +RET_LABEL38:(void)0; } -var82 = var94; -} else { -var82 = var_86; } -var_99 = var82; -if (var82){ +if (var37){ { -{ /* Inline model#MClassType#mclass (var_mtype) on */ -var102 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var102 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1058); -show_backtrace(1); -} -var100 = var102; -RET_LABEL101:(void)0; -} +var41 = standard___standard__SequenceRead___Collection__first(var_args); } { -{ /* Inline model#MClass#name (var100) on */ -var105 = var100->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ -if (unlikely(var105 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 348); -show_backtrace(1); -} -var103 = var105; -RET_LABEL104:(void)0; +{ /* Inline model#MPropDef#mclassdef (var_m) on */ +var44 = var_m->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var44 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2209); +fatal_exit(1); } +var42 = var44; +RET_LABEL43:(void)0; } -if (varonce106) { -var107 = varonce106; -} else { -var108 = "NativeString"; -var109 = 12; -var110 = standard___standard__NativeString___to_s_with_length(var108, var109); -var107 = var110; -varonce106 = var107; } { -{ /* Inline kernel#Object#!= (var103,var107) on */ -var_other113 = var107; -{ -var114 = ((short int (*)(val* self, val* p0))(var103->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var103, var_other113) /* == on */; -} -var115 = !var114; -var111 = var115; -goto RET_LABEL112; -RET_LABEL112:(void)0; +{ /* Inline model#MClassDef#mclass (var42) on */ +var47 = var42->attrs[COLOR_nit__model__MClassDef___mclass].val; /* _mclass on */ +if (unlikely(var47 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 553); +fatal_exit(1); } +var45 = var47; +RET_LABEL46:(void)0; } -var81 = var111; -} else { -var81 = var_99; } -if (var81){ { -{ /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on */ -var118 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ -if (unlikely(var118 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1059); -show_backtrace(1); +{ /* Inline model#MClass#mclass_type (var45) on */ +var50 = var45->attrs[COLOR_nit__model__MClass___mclass_type].val; /* _mclass_type on */ +if (unlikely(var50 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass_type"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 484); +fatal_exit(1); } -var116 = var118; -RET_LABEL117:(void)0; +var48 = var50; +RET_LABEL49:(void)0; } } { -{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (var116) on */ -var121 = var116->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ -if (unlikely(var121 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); -show_backtrace(1); -} -var119 = var121; -RET_LABEL120:(void)0; -} +var51 = nit___nit__SeparateCompilerVisitor___nit__abstract_compiler__AbstractCompilerVisitor__autobox(self, var41, var48); } { -var122 = nit__model___MModule___pointer_type(var119); +standard___standard__Sequence___first_61d(var_args, var51); /* Direct call abstract_collection#Sequence#first= on */ } -var_valtype = var122; } else { } +var_i = 0l; { -var123 = nit___nit__AbstractCompilerVisitor___new_var(self, var_mtype); +var52 = nit___nit__MSignature___arity(var_msignature); } -var_res = var123; +var_ = var52; +for(;;) { { -{ /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on */ -var127 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ -if (unlikely(var127 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1059); -show_backtrace(1); +{ /* Inline kernel#Int#< (var_i,var_) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var55 = 1; /* easy isa OTHER*/ +if (unlikely(!var55)) { +var_class_name = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 534); +fatal_exit(1); } -var125 = var127; -RET_LABEL126:(void)0; +var56 = var_i < var_; +var53 = var56; +goto RET_LABEL54; +RET_LABEL54:(void)0; } } +if (var53){ { -{ /* Inline separate_compiler#SeparateCompiler#runtime_type_analysis (var125) on */ -var130 = var125->attrs[COLOR_nit__separate_compiler__SeparateCompiler___runtime_type_analysis].val; /* _runtime_type_analysis on */ -var128 = var130; -RET_LABEL129:(void)0; +{ /* Inline model#MSignature#mparameters (var_msignature) on */ +var59 = var_msignature->attrs[COLOR_nit__model__MSignature___mparameters].val; /* _mparameters on */ +if (unlikely(var59 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mparameters"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1756); +fatal_exit(1); } +var57 = var59; +RET_LABEL58:(void)0; } -var131 = NULL; -if (var128 == NULL) { -var132 = 0; /* is null */ -} else { -var132 = 1; /* arg is null and recv is not */ } -if (0) { -{ /* Inline kernel#Object#!= (var128,var131) on */ -var_other113 = var131; { -var135 = ((short int (*)(val* self, val* p0))(var128->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var128, var_other113) /* == on */; -} -var136 = !var135; -var133 = var136; -goto RET_LABEL134; -RET_LABEL134:(void)0; +var60 = standard___standard__Array___standard__abstract_collection__SequenceRead___91d_93d(var57, var_i); } -var132 = var133; -} -var_137 = var132; -if (var132){ { -{ /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on */ -var140 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ -if (unlikely(var140 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1059); -show_backtrace(1); +{ /* Inline model#MParameter#mtype (var60) on */ +var63 = var60->attrs[COLOR_nit__model__MParameter___mtype].val; /* _mtype on */ +if (unlikely(var63 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1879); +fatal_exit(1); } -var138 = var140; -RET_LABEL139:(void)0; +var61 = var63; +RET_LABEL62:(void)0; } } +var_t = var61; { -{ /* Inline separate_compiler#SeparateCompiler#runtime_type_analysis (var138) on */ -var143 = var138->attrs[COLOR_nit__separate_compiler__SeparateCompiler___runtime_type_analysis].val; /* _runtime_type_analysis on */ -var141 = var143; -RET_LABEL142:(void)0; -} -} -if (var141 == NULL) { -PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 1003); -show_backtrace(1); -} else { -{ /* Inline rapid_type_analysis#RapidTypeAnalysis#live_types (var141) on */ -if (unlikely(var141 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 53); -show_backtrace(1); -} -var146 = var141->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on */ -if (unlikely(var146 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 53); -show_backtrace(1); -} -var144 = var146; -RET_LABEL145:(void)0; +{ /* Inline model#MSignature#vararg_rank (var_msignature) on */ +var66 = var_msignature->attrs[COLOR_nit__model__MSignature___vararg_rank].l; /* _vararg_rank on */ +var64 = var66; +RET_LABEL65:(void)0; } } { -var147 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var144, var_valtype); -} -var148 = !var147; -var124 = var148; -} else { -var124 = var_137; +{ /* Inline kernel#Int#== (var_i,var64) on */ +var69 = var_i == var64; +var67 = var69; +goto RET_LABEL68; +RET_LABEL68:(void)0; } -if (var124){ -if (varonce149) { -var150 = varonce149; -} else { -var151 = "/*no autobox from "; -var152 = 18; -var153 = standard___standard__NativeString___to_s_with_length(var151, var152); -var150 = var153; -varonce149 = var150; } +if (var67){ { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var156 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var156 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); -} -var154 = var156; -RET_LABEL155:(void)0; +{ /* Inline kernel#Int#+ (var_i,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var72 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var72)) { +var_class_name75 = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name75); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 537); +fatal_exit(1); } +var76 = var_i + 1l; +var70 = var76; +goto RET_LABEL71; +RET_LABEL71:(void)0; } -if (varonce157) { -var158 = varonce157; -} else { -var159 = " to "; -var160 = 4; -var161 = standard___standard__NativeString___to_s_with_length(var159, var160); -var158 = var161; -varonce157 = var158; } -if (varonce162) { -var163 = varonce162; -} else { -var164 = ": "; -var165 = 2; -var166 = standard___standard__NativeString___to_s_with_length(var164, var165); -var163 = var166; -varonce162 = var163; +{ +var77 = standard___standard__Array___standard__abstract_collection__SequenceRead___91d_93d(var_args, var70); } { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var169 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var169 == NULL)) { +{ /* Inline abstract_compiler#RuntimeVariable#mtype (var77) on */ +var80 = var77->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var80 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1784); +fatal_exit(1); } -var167 = var169; -RET_LABEL168:(void)0; +var78 = var80; +RET_LABEL79:(void)0; } } -if (varonce170) { -var171 = varonce170; +var_t = var78; } else { -var172 = " is not live! */"; -var173 = 16; -var174 = standard___standard__NativeString___to_s_with_length(var172, var173); -var171 = var174; -varonce170 = var171; } -var175 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var175 = array_instance Array[Object] */ -var176 = 7; -var177 = NEW_standard__NativeArray(var176, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var177)->values[0] = (val*) var150; -((struct instance_standard__NativeArray*)var177)->values[1] = (val*) var154; -((struct instance_standard__NativeArray*)var177)->values[2] = (val*) var158; -((struct instance_standard__NativeArray*)var177)->values[3] = (val*) var_mtype; -((struct instance_standard__NativeArray*)var177)->values[4] = (val*) var163; -((struct instance_standard__NativeArray*)var177)->values[5] = (val*) var167; -((struct instance_standard__NativeArray*)var177)->values[6] = (val*) var171; { -((void (*)(val* self, val* p0, long p1))(var175->class->vft[COLOR_standard__array__Array__with_native]))(var175, var177, var176) /* with_native on */; +{ /* Inline kernel#Int#+ (var_i,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var83 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var83)) { +var_class_name86 = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name86); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 537); +fatal_exit(1); } +var87 = var_i + 1l; +var81 = var87; +goto RET_LABEL82; +RET_LABEL82:(void)0; } -{ -var178 = ((val* (*)(val* self))(var175->class->vft[COLOR_standard__string__Object__to_s]))(var175) /* to_s on */; } { -nit___nit__AbstractCompilerVisitor___add(self, var178); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +{ /* Inline kernel#Int#+ (var_i,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var90 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var90)) { +var_class_name93 = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name93); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 537); +fatal_exit(1); } -if (varonce179) { -var180 = varonce179; -} else { -var181 = "PRINT_ERROR(\"Dead code executed!\\n\"); show_backtrace(1);"; -var182 = 56; -var183 = standard___standard__NativeString___to_s_with_length(var181, var182); -var180 = var183; -varonce179 = var180; +var94 = var_i + 1l; +var88 = var94; +goto RET_LABEL89; +RET_LABEL89:(void)0; } -{ -nit___nit__AbstractCompilerVisitor___add(self, var180); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -var = var_res; -goto RET_LABEL; -} else { +{ +var95 = standard___standard__Array___standard__abstract_collection__SequenceRead___91d_93d(var_args, var88); } -if (varonce184) { -var185 = varonce184; -} else { -var186 = "BOX_"; -var187 = 4; -var188 = standard___standard__NativeString___to_s_with_length(var186, var187); -var185 = var188; -varonce184 = var185; +{ +var96 = nit___nit__SeparateCompilerVisitor___nit__abstract_compiler__AbstractCompilerVisitor__autobox(self, var95, var_t); } { -var189 = ((val* (*)(val* self))(var_valtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_valtype) /* c_name on */; +standard___standard__Array___standard__abstract_collection__Sequence___91d_93d_61d(var_args, var81, var96); /* Direct call array#Array#[]= on */ } -var190 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var190 = array_instance Array[Object] */ -var191 = 2; -var192 = NEW_standard__NativeArray(var191, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var192)->values[0] = (val*) var185; -((struct instance_standard__NativeArray*)var192)->values[1] = (val*) var189; { -((void (*)(val* self, val* p0, long p1))(var190->class->vft[COLOR_standard__array__Array__with_native]))(var190, var192, var191) /* with_native on */; +var97 = standard___standard__Int___Discrete__successor(var_i, 1l); +} +var_i = var97; +} else { +goto BREAK_label; } } -{ -var193 = ((val* (*)(val* self))(var190->class->vft[COLOR_standard__string__Object__to_s]))(var190) /* to_s on */; +BREAK_label: (void)0; +RET_LABEL:; } +/* method separate_compiler#SeparateCompilerVisitor#unbox_signature_extern for (self: SeparateCompilerVisitor, MMethodDef, Array[RuntimeVariable]) */ +void nit___nit__SeparateCompilerVisitor___nit__abstract_compiler__AbstractCompilerVisitor__unbox_signature_extern(val* self, val* p0, val* p1) { +val* var_m /* var m: MMethodDef */; +val* var_args /* var args: Array[RuntimeVariable] */; +val* var /* : nullable MSignature */; +val* var2 /* : nullable MSignature */; +val* var3 /* : MClassDef */; +val* var5 /* : MClassDef */; +val* var6 /* : MClassType */; +val* var8 /* : MClassType */; +val* var9 /* : MClassDef */; +val* var11 /* : MClassDef */; +val* var12 /* : MClassType */; +val* var14 /* : MClassType */; +val* var15 /* : MClassDef */; +val* var17 /* : MClassDef */; +val* var18 /* : MModule */; +val* var20 /* : MModule */; +val* var21 /* : MSignature */; +val* var_msignature /* var msignature: MSignature */; +short int var22 /* : Bool */; +val* var23 /* : MProperty */; +val* var25 /* : MProperty */; +short int var26 /* : Bool */; +short int var28 /* : Bool */; +short int var29 /* : Bool */; +short int var_ /* var : Bool */; +short int var30 /* : Bool */; +short int var32 /* : Bool */; +val* var33 /* : nullable Object */; +val* var34 /* : MClassDef */; +val* var36 /* : MClassDef */; +val* var37 /* : MClass */; +val* var39 /* : MClass */; +val* var40 /* : MClassType */; +val* var42 /* : MClassType */; +val* var43 /* : RuntimeVariable */; +long var_i /* var i: Int */; +long var44 /* : Int */; +long var_45 /* var : Int */; +short int var46 /* : Bool */; +short int var48 /* : Bool */; +int cltype; +int idtype; +const char* var_class_name; +short int var49 /* : Bool */; +val* var50 /* : Array[MParameter] */; +val* var52 /* : Array[MParameter] */; +val* var53 /* : nullable Object */; +val* var54 /* : MType */; +val* var56 /* : MType */; +val* var_t /* var t: MType */; +long var57 /* : Int */; +long var59 /* : Int */; +short int var60 /* : Bool */; +short int var62 /* : Bool */; +long var63 /* : Int */; +short int var65 /* : Bool */; +int cltype66; +int idtype67; +const char* var_class_name68; +long var69 /* : Int */; +val* var70 /* : nullable Object */; +val* var71 /* : MType */; +val* var73 /* : MType */; +short int var74 /* : Bool */; +short int var76 /* : Bool */; +long var77 /* : Int */; +short int var79 /* : Bool */; +int cltype80; +int idtype81; +const char* var_class_name82; +long var83 /* : Int */; +long var84 /* : Int */; +short int var86 /* : Bool */; +int cltype87; +int idtype88; +const char* var_class_name89; +long var90 /* : Int */; +val* var91 /* : nullable Object */; +val* var92 /* : RuntimeVariable */; +long var93 /* : Int */; +var_m = p0; +var_args = p1; { -nit___nit__AbstractCompilerVisitor___require_declaration(self, var193); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +{ /* Inline model#MMethodDef#msignature (var_m) on */ +var2 = var_m->attrs[COLOR_nit__model__MMethodDef___msignature].val; /* _msignature on */ +var = var2; +RET_LABEL1:(void)0; } -if (varonce194) { -var195 = varonce194; -} else { -var196 = " = BOX_"; -var197 = 7; -var198 = standard___standard__NativeString___to_s_with_length(var196, var197); -var195 = var198; -varonce194 = var195; } { -var199 = ((val* (*)(val* self))(var_valtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_valtype) /* c_name on */; +{ /* Inline model#MPropDef#mclassdef (var_m) on */ +var5 = var_m->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var5 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2209); +fatal_exit(1); } -if (varonce200) { -var201 = varonce200; -} else { -var202 = "("; -var203 = 1; -var204 = standard___standard__NativeString___to_s_with_length(var202, var203); -var201 = var204; -varonce200 = var201; +var3 = var5; +RET_LABEL4:(void)0; } -if (varonce205) { -var206 = varonce205; -} else { -var207 = "); /* autobox from "; -var208 = 19; -var209 = standard___standard__NativeString___to_s_with_length(var207, var208); -var206 = var209; -varonce205 = var206; } { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var212 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var212 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); -} -var210 = var212; -RET_LABEL211:(void)0; -} +{ /* Inline model#MClassDef#bound_mtype (var3) on */ +var8 = var3->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ +if (unlikely(var8 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 556); +fatal_exit(1); } -if (varonce213) { -var214 = varonce213; -} else { -var215 = " to "; -var216 = 4; -var217 = standard___standard__NativeString___to_s_with_length(var215, var216); -var214 = var217; -varonce213 = var214; +var6 = var8; +RET_LABEL7:(void)0; } -if (varonce218) { -var219 = varonce218; -} else { -var220 = " */"; -var221 = 3; -var222 = standard___standard__NativeString___to_s_with_length(var220, var221); -var219 = var222; -varonce218 = var219; } -var223 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var223 = array_instance Array[Object] */ -var224 = 10; -var225 = NEW_standard__NativeArray(var224, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var225)->values[0] = (val*) var_res; -((struct instance_standard__NativeArray*)var225)->values[1] = (val*) var195; -((struct instance_standard__NativeArray*)var225)->values[2] = (val*) var199; -((struct instance_standard__NativeArray*)var225)->values[3] = (val*) var201; -((struct instance_standard__NativeArray*)var225)->values[4] = (val*) var_value; -((struct instance_standard__NativeArray*)var225)->values[5] = (val*) var206; -((struct instance_standard__NativeArray*)var225)->values[6] = (val*) var210; -((struct instance_standard__NativeArray*)var225)->values[7] = (val*) var214; -((struct instance_standard__NativeArray*)var225)->values[8] = (val*) var_mtype; -((struct instance_standard__NativeArray*)var225)->values[9] = (val*) var219; { -((void (*)(val* self, val* p0, long p1))(var223->class->vft[COLOR_standard__array__Array__with_native]))(var223, var225, var224) /* with_native on */; -} +{ /* Inline model#MPropDef#mclassdef (var_m) on */ +var11 = var_m->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var11 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2209); +fatal_exit(1); } -{ -var226 = ((val* (*)(val* self))(var223->class->vft[COLOR_standard__string__Object__to_s]))(var223) /* to_s on */; +var9 = var11; +RET_LABEL10:(void)0; } -{ -nit___nit__AbstractCompilerVisitor___add(self, var226); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -var = var_res; -goto RET_LABEL; -} else { { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var232 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var232 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); +{ /* Inline model#MClassDef#bound_mtype (var9) on */ +var14 = var9->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ +if (unlikely(var14 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 556); +fatal_exit(1); } -var230 = var232; -RET_LABEL231:(void)0; +var12 = var14; +RET_LABEL13:(void)0; } } { -var233 = ((val* (*)(val* self))(var230->class->vft[COLOR_nit__abstract_compiler__MType__ctype]))(var230) /* ctype on */; +{ /* Inline model#MPropDef#mclassdef (var_m) on */ +var17 = var_m->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var17 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2209); +fatal_exit(1); } -if (varonce234) { -var235 = varonce234; -} else { -var236 = "void*"; -var237 = 5; -var238 = standard___standard__NativeString___to_s_with_length(var236, var237); -var235 = var238; -varonce234 = var235; +var15 = var17; +RET_LABEL16:(void)0; } -{ -var239 = ((short int (*)(val* self, val* p0))(var233->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var233, var235) /* == on */; } -var_240 = var239; -if (var239){ { -var241 = ((val* (*)(val* self))(var_mtype->class->vft[COLOR_nit__abstract_compiler__MType__ctype]))(var_mtype) /* ctype on */; +{ /* Inline model#MClassDef#mmodule (var15) on */ +var20 = var15->attrs[COLOR_nit__model__MClassDef___mmodule].val; /* _mmodule on */ +if (unlikely(var20 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mmodule"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 550); +fatal_exit(1); } -if (varonce242) { -var243 = varonce242; -} else { -var244 = "void*"; -var245 = 5; -var246 = standard___standard__NativeString___to_s_with_length(var244, var245); -var243 = var246; -varonce242 = var243; +var18 = var20; +RET_LABEL19:(void)0; } -{ -var247 = ((short int (*)(val* self, val* p0))(var241->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var241, var243) /* == on */; } -var229 = var247; +if (var == NULL) { +PRINT_ERROR("Runtime error: %s", "Receiver is null"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_compiler, 1173); +fatal_exit(1); } else { -var229 = var_240; +var21 = nit___nit__MSignature___MType__resolve_for(var, var6, var12, var18, 1); } -var_248 = var229; -if (var229){ -var228 = var_248; -} else { +var_msignature = var21; { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var252 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var252 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); +{ /* Inline model#MPropDef#mproperty (var_m) on */ +var25 = var_m->attrs[COLOR_nit__model__MPropDef___mproperty].val; /* _mproperty on */ +if (unlikely(var25 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mproperty"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2212); +fatal_exit(1); } -var250 = var252; -RET_LABEL251:(void)0; +var23 = var25; +RET_LABEL24:(void)0; } } { -var253 = ((val* (*)(val* self))(var250->class->vft[COLOR_nit__abstract_compiler__MType__ctype]))(var250) /* ctype on */; +{ /* Inline model#MMethod#is_init (var23) on */ +var28 = var23->attrs[COLOR_nit__model__MMethod___is_init].s; /* _is_init on */ +var26 = var28; +RET_LABEL27:(void)0; } -if (varonce254) { -var255 = varonce254; -} else { -var256 = "char*"; -var257 = 5; -var258 = standard___standard__NativeString___to_s_with_length(var256, var257); -var255 = var258; -varonce254 = var255; } +var29 = !var26; +var_ = var29; +if (var29){ { -var259 = ((short int (*)(val* self, val* p0))(var253->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var253, var255) /* == on */; +{ /* Inline model#MMethodDef#is_extern (var_m) on */ +var32 = var_m->attrs[COLOR_nit__model__MMethodDef___is_extern].s; /* _is_extern on */ +var30 = var32; +RET_LABEL31:(void)0; } -var_260 = var259; -if (var259){ -{ -var261 = ((val* (*)(val* self))(var_mtype->class->vft[COLOR_nit__abstract_compiler__MType__ctype]))(var_mtype) /* ctype on */; } -if (varonce262) { -var263 = varonce262; +var22 = var30; } else { -var264 = "void*"; -var265 = 5; -var266 = standard___standard__NativeString___to_s_with_length(var264, var265); -var263 = var266; -varonce262 = var263; +var22 = var_; } +if (var22){ { -var267 = ((short int (*)(val* self, val* p0))(var261->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var261, var263) /* == on */; -} -var249 = var267; -} else { -var249 = var_260; -} -var228 = var249; +var33 = standard___standard__SequenceRead___Collection__first(var_args); } -var_268 = var228; -if (var228){ -var227 = var_268; -} else { { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var272 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var272 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); -} -var270 = var272; -RET_LABEL271:(void)0; -} +{ /* Inline model#MPropDef#mclassdef (var_m) on */ +var36 = var_m->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var36 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2209); +fatal_exit(1); } -{ -var273 = ((val* (*)(val* self))(var270->class->vft[COLOR_nit__abstract_compiler__MType__ctype]))(var270) /* ctype on */; +var34 = var36; +RET_LABEL35:(void)0; } -if (varonce274) { -var275 = varonce274; -} else { -var276 = "void*"; -var277 = 5; -var278 = standard___standard__NativeString___to_s_with_length(var276, var277); -var275 = var278; -varonce274 = var275; } { -var279 = ((short int (*)(val* self, val* p0))(var273->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var273, var275) /* == on */; +{ /* Inline model#MClassDef#mclass (var34) on */ +var39 = var34->attrs[COLOR_nit__model__MClassDef___mclass].val; /* _mclass on */ +if (unlikely(var39 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 553); +fatal_exit(1); } -var_280 = var279; -if (var279){ -{ -var281 = ((val* (*)(val* self))(var_mtype->class->vft[COLOR_nit__abstract_compiler__MType__ctype]))(var_mtype) /* ctype on */; +var37 = var39; +RET_LABEL38:(void)0; } -if (varonce282) { -var283 = varonce282; -} else { -var284 = "char*"; -var285 = 5; -var286 = standard___standard__NativeString___to_s_with_length(var284, var285); -var283 = var286; -varonce282 = var283; } { -var287 = ((short int (*)(val* self, val* p0))(var281->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var281, var283) /* == on */; +{ /* Inline model#MClass#mclass_type (var37) on */ +var42 = var37->attrs[COLOR_nit__model__MClass___mclass_type].val; /* _mclass_type on */ +if (unlikely(var42 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass_type"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 484); +fatal_exit(1); } -var269 = var287; -} else { -var269 = var_280; +var40 = var42; +RET_LABEL41:(void)0; } -var227 = var269; } -if (var227){ -var = var_value; -goto RET_LABEL; -} else { { -var288 = nit___nit__AbstractCompilerVisitor___new_var(self, var_mtype); -} -var_res289 = var288; -if (varonce290) { -var291 = varonce290; -} else { -var292 = "/* "; -var293 = 3; -var294 = standard___standard__NativeString___to_s_with_length(var292, var293); -var291 = var294; -varonce290 = var291; -} -if (varonce295) { -var296 = varonce295; -} else { -var297 = " left unintialized (cannot convert "; -var298 = 35; -var299 = standard___standard__NativeString___to_s_with_length(var297, var298); -var296 = var299; -varonce295 = var296; +var43 = ((val*(*)(val* self, val* p0, val* p1))(self->class->vft[COLOR_nit__abstract_compiler__AbstractCompilerVisitor__unbox_extern]))(self, var33, var40); /* unbox_extern on */ } { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var302 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var302 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); -} -var300 = var302; -RET_LABEL301:(void)0; -} +standard___standard__Sequence___first_61d(var_args, var43); /* Direct call abstract_collection#Sequence#first= on */ } -if (varonce303) { -var304 = varonce303; } else { -var305 = " to "; -var306 = 4; -var307 = standard___standard__NativeString___to_s_with_length(var305, var306); -var304 = var307; -varonce303 = var304; } -if (varonce308) { -var309 = varonce308; -} else { -var310 = ") */"; -var311 = 4; -var312 = standard___standard__NativeString___to_s_with_length(var310, var311); -var309 = var312; -varonce308 = var309; -} -var313 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var313 = array_instance Array[Object] */ -var314 = 7; -var315 = NEW_standard__NativeArray(var314, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var315)->values[0] = (val*) var291; -((struct instance_standard__NativeArray*)var315)->values[1] = (val*) var_res289; -((struct instance_standard__NativeArray*)var315)->values[2] = (val*) var296; -((struct instance_standard__NativeArray*)var315)->values[3] = (val*) var300; -((struct instance_standard__NativeArray*)var315)->values[4] = (val*) var304; -((struct instance_standard__NativeArray*)var315)->values[5] = (val*) var_mtype; -((struct instance_standard__NativeArray*)var315)->values[6] = (val*) var309; +var_i = 0l; { -((void (*)(val* self, val* p0, long p1))(var313->class->vft[COLOR_standard__array__Array__with_native]))(var313, var315, var314) /* with_native on */; -} +var44 = nit___nit__MSignature___arity(var_msignature); } +var_45 = var44; +for(;;) { { -var316 = ((val* (*)(val* self))(var313->class->vft[COLOR_standard__string__Object__to_s]))(var313) /* to_s on */; +{ /* Inline kernel#Int#< (var_i,var_45) on */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var48 = 1; /* easy isa OTHER*/ +if (unlikely(!var48)) { +var_class_name = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 534); +fatal_exit(1); } -{ -nit___nit__AbstractCompilerVisitor___add(self, var316); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +var49 = var_i < var_45; +var46 = var49; +goto RET_LABEL47; +RET_LABEL47:(void)0; } -if (varonce317) { -var318 = varonce317; -} else { -var319 = "PRINT_ERROR(\"Cast error: Cannot cast %s to %s.\\n\", \""; -var320 = 52; -var321 = standard___standard__NativeString___to_s_with_length(var319, var320); -var318 = var321; -varonce317 = var318; } +if (var46){ { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var324 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var324 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); -} -var322 = var324; -RET_LABEL323:(void)0; -} -} -if (varonce325) { -var326 = varonce325; -} else { -var327 = "\", \""; -var328 = 4; -var329 = standard___standard__NativeString___to_s_with_length(var327, var328); -var326 = var329; -varonce325 = var326; -} -if (varonce330) { -var331 = varonce330; -} else { -var332 = "\"); show_backtrace(1);"; -var333 = 22; -var334 = standard___standard__NativeString___to_s_with_length(var332, var333); -var331 = var334; -varonce330 = var331; +{ /* Inline model#MSignature#mparameters (var_msignature) on */ +var52 = var_msignature->attrs[COLOR_nit__model__MSignature___mparameters].val; /* _mparameters on */ +if (unlikely(var52 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mparameters"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1756); +fatal_exit(1); } -var335 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var335 = array_instance Array[Object] */ -var336 = 5; -var337 = NEW_standard__NativeArray(var336, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var337)->values[0] = (val*) var318; -((struct instance_standard__NativeArray*)var337)->values[1] = (val*) var322; -((struct instance_standard__NativeArray*)var337)->values[2] = (val*) var326; -((struct instance_standard__NativeArray*)var337)->values[3] = (val*) var_mtype; -((struct instance_standard__NativeArray*)var337)->values[4] = (val*) var331; -{ -((void (*)(val* self, val* p0, long p1))(var335->class->vft[COLOR_standard__array__Array__with_native]))(var335, var337, var336) /* with_native on */; +var50 = var52; +RET_LABEL51:(void)0; } } { -var338 = ((val* (*)(val* self))(var335->class->vft[COLOR_standard__string__Object__to_s]))(var335) /* to_s on */; +var53 = standard___standard__Array___standard__abstract_collection__SequenceRead___91d_93d(var50, var_i); } { -nit___nit__AbstractCompilerVisitor___add(self, var338); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ -} -var = var_res289; -goto RET_LABEL; -} -} -} -} +{ /* Inline model#MParameter#mtype (var53) on */ +var56 = var53->attrs[COLOR_nit__model__MParameter___mtype].val; /* _mtype on */ +if (unlikely(var56 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1879); +fatal_exit(1); } -RET_LABEL:; -return var; +var54 = var56; +RET_LABEL55:(void)0; } -/* method separate_compiler#SeparateCompilerVisitor#unbox_extern for (self: SeparateCompilerVisitor, RuntimeVariable, MType): RuntimeVariable */ -val* nit___nit__SeparateCompilerVisitor___nit__abstract_compiler__AbstractCompilerVisitor__unbox_extern(val* self, val* p0, val* p1) { -val* var /* : RuntimeVariable */; -val* var_value /* var value: RuntimeVariable */; -val* var_mtype /* var mtype: MType */; -short int var1 /* : Bool */; -short int var2 /* : Bool */; -short int var3 /* : Bool */; -int cltype; -int idtype; -short int var_ /* var : Bool */; -val* var4 /* : MClass */; -val* var6 /* : MClass */; -val* var7 /* : MClassKind */; -val* var9 /* : MClassKind */; -val* var10 /* : MClassKind */; -short int var11 /* : Bool */; -val* var_other /* var other: nullable Object */; -short int var13 /* : Bool */; -short int var15 /* : Bool */; -short int var_16 /* var : Bool */; -val* var17 /* : MClass */; -val* var19 /* : MClass */; -val* var20 /* : String */; -val* var22 /* : String */; -static val* varonce; -val* var23 /* : String */; -char* var24 /* : NativeString */; -long var25 /* : Int */; -val* var26 /* : FlatString */; -short int var27 /* : Bool */; -val* var_other29 /* var other: nullable Object */; -short int var30 /* : Bool */; -short int var31 /* : Bool */; -val* var32 /* : AbstractCompiler */; -val* var34 /* : AbstractCompiler */; -val* var35 /* : MModule */; -val* var37 /* : MModule */; -val* var38 /* : MClassType */; -val* var_pointer_type /* var pointer_type: MClassType */; -val* var39 /* : RuntimeVariable */; -val* var_res /* var res: RuntimeVariable */; -static val* varonce40; -val* var41 /* : String */; -char* var42 /* : NativeString */; -long var43 /* : Int */; -val* var44 /* : FlatString */; -val* var45 /* : String */; -static val* varonce46; -val* var47 /* : String */; -char* var48 /* : NativeString */; -long var49 /* : Int */; -val* var50 /* : FlatString */; -static val* varonce51; -val* var52 /* : String */; -char* var53 /* : NativeString */; -long var54 /* : Int */; -val* var55 /* : FlatString */; -val* var56 /* : MType */; -val* var58 /* : MType */; -static val* varonce59; -val* var60 /* : String */; -char* var61 /* : NativeString */; -long var62 /* : Int */; -val* var63 /* : FlatString */; -val* var64 /* : Array[Object] */; -long var65 /* : Int */; -val* var66 /* : NativeArray[Object] */; -val* var67 /* : String */; -var_value = p0; -var_mtype = p1; -/* isa MClassType */ -cltype = type_nit__MClassType.color; -idtype = type_nit__MClassType.id; -if(cltype >= var_mtype->type->table_size) { -var3 = 0; -} else { -var3 = var_mtype->type->type_table[cltype] == idtype; } -var_ = var3; -if (var3){ +var_t = var54; { -{ /* Inline model#MClassType#mclass (var_mtype) on */ -var6 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var6 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1058); -show_backtrace(1); -} -var4 = var6; -RET_LABEL5:(void)0; +{ /* Inline model#MSignature#vararg_rank (var_msignature) on */ +var59 = var_msignature->attrs[COLOR_nit__model__MSignature___vararg_rank].l; /* _vararg_rank on */ +var57 = var59; +RET_LABEL58:(void)0; } } { -{ /* Inline model#MClass#kind (var4) on */ -var9 = var4->attrs[COLOR_nit__model__MClass___kind].val; /* _kind on */ -if (unlikely(var9 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _kind"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 399); -show_backtrace(1); -} -var7 = var9; -RET_LABEL8:(void)0; -} +{ /* Inline kernel#Int#== (var_i,var57) on */ +var62 = var_i == var57; +var60 = var62; +goto RET_LABEL61; +RET_LABEL61:(void)0; } -{ -var10 = nit__model___standard__Object___extern_kind(self); } +if (var60){ { -{ /* Inline kernel#Object#== (var7,var10) on */ -var_other = var10; -{ -{ /* Inline kernel#Object#is_same_instance (var7,var_other) on */ -var15 = var7 == var_other; -var13 = var15; -goto RET_LABEL14; -RET_LABEL14:(void)0; -} -} -var11 = var13; -goto RET_LABEL12; -RET_LABEL12:(void)0; +{ /* Inline kernel#Int#+ (var_i,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var65 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var65)) { +var_class_name68 = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name68); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 537); +fatal_exit(1); } +var69 = var_i + 1l; +var63 = var69; +goto RET_LABEL64; +RET_LABEL64:(void)0; } -var2 = var11; -} else { -var2 = var_; } -var_16 = var2; -if (var2){ { -{ /* Inline model#MClassType#mclass (var_mtype) on */ -var19 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var19 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1058); -show_backtrace(1); -} -var17 = var19; -RET_LABEL18:(void)0; -} +var70 = standard___standard__Array___standard__abstract_collection__SequenceRead___91d_93d(var_args, var63); } { -{ /* Inline model#MClass#name (var17) on */ -var22 = var17->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ -if (unlikely(var22 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 348); -show_backtrace(1); +{ /* Inline abstract_compiler#RuntimeVariable#mtype (var70) on */ +var73 = var70->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var73 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1784); +fatal_exit(1); } -var20 = var22; -RET_LABEL21:(void)0; +var71 = var73; +RET_LABEL72:(void)0; } } -if (varonce) { -var23 = varonce; +var_t = var71; } else { -var24 = "NativeString"; -var25 = 12; -var26 = standard___standard__NativeString___to_s_with_length(var24, var25); -var23 = var26; -varonce = var23; } { -{ /* Inline kernel#Object#!= (var20,var23) on */ -var_other29 = var23; -{ -var30 = ((short int (*)(val* self, val* p0))(var20->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var20, var_other29) /* == on */; -} -var31 = !var30; -var27 = var31; -goto RET_LABEL28; -RET_LABEL28:(void)0; -} +{ /* Inline model#MMethodDef#is_extern (var_m) on */ +var76 = var_m->attrs[COLOR_nit__model__MMethodDef___is_extern].s; /* _is_extern on */ +var74 = var76; +RET_LABEL75:(void)0; } -var1 = var27; -} else { -var1 = var_16; } -if (var1){ +if (var74){ { -{ /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on */ -var34 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ -if (unlikely(var34 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1059); -show_backtrace(1); +{ /* Inline kernel#Int#+ (var_i,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var79 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var79)) { +var_class_name82 = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name82); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 537); +fatal_exit(1); } -var32 = var34; -RET_LABEL33:(void)0; +var83 = var_i + 1l; +var77 = var83; +goto RET_LABEL78; +RET_LABEL78:(void)0; } } { -{ /* Inline abstract_compiler#AbstractCompiler#mainmodule (var32) on */ -var37 = var32->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ -if (unlikely(var37 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); -show_backtrace(1); +{ /* Inline kernel#Int#+ (var_i,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var86 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var86)) { +var_class_name89 = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name89); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 537); +fatal_exit(1); } -var35 = var37; -RET_LABEL36:(void)0; +var90 = var_i + 1l; +var84 = var90; +goto RET_LABEL85; +RET_LABEL85:(void)0; } } { -var38 = nit__model___MModule___pointer_type(var35); +var91 = standard___standard__Array___standard__abstract_collection__SequenceRead___91d_93d(var_args, var84); } -var_pointer_type = var38; { -var39 = nit___nit__AbstractCompilerVisitor___new_var_extern(self, var_mtype); -} -var_res = var39; -if (varonce40) { -var41 = varonce40; -} else { -var42 = " = ((struct instance_"; -var43 = 21; -var44 = standard___standard__NativeString___to_s_with_length(var42, var43); -var41 = var44; -varonce40 = var41; +var92 = ((val*(*)(val* self, val* p0, val* p1))(self->class->vft[COLOR_nit__abstract_compiler__AbstractCompilerVisitor__unbox_extern]))(self, var91, var_t); /* unbox_extern on */ } { -var45 = ((val* (*)(val* self))(var_pointer_type->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_pointer_type) /* c_name on */; -} -if (varonce46) { -var47 = varonce46; -} else { -var48 = "*)"; -var49 = 2; -var50 = standard___standard__NativeString___to_s_with_length(var48, var49); -var47 = var50; -varonce46 = var47; +standard___standard__Array___standard__abstract_collection__Sequence___91d_93d_61d(var_args, var77, var92); /* Direct call array#Array#[]= on */ } -if (varonce51) { -var52 = varonce51; } else { -var53 = ")->value; /* unboxing "; -var54 = 22; -var55 = standard___standard__NativeString___to_s_with_length(var53, var54); -var52 = var55; -varonce51 = var52; } { -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var58 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var58 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); -} -var56 = var58; -RET_LABEL57:(void)0; +var93 = standard___standard__Int___Discrete__successor(var_i, 1l); } -} -if (varonce59) { -var60 = varonce59; +var_i = var93; } else { -var61 = " */"; -var62 = 3; -var63 = standard___standard__NativeString___to_s_with_length(var61, var62); -var60 = var63; -varonce59 = var60; -} -var64 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var64 = array_instance Array[Object] */ -var65 = 8; -var66 = NEW_standard__NativeArray(var65, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var66)->values[0] = (val*) var_res; -((struct instance_standard__NativeArray*)var66)->values[1] = (val*) var41; -((struct instance_standard__NativeArray*)var66)->values[2] = (val*) var45; -((struct instance_standard__NativeArray*)var66)->values[3] = (val*) var47; -((struct instance_standard__NativeArray*)var66)->values[4] = (val*) var_value; -((struct instance_standard__NativeArray*)var66)->values[5] = (val*) var52; -((struct instance_standard__NativeArray*)var66)->values[6] = (val*) var56; -((struct instance_standard__NativeArray*)var66)->values[7] = (val*) var60; -{ -((void (*)(val* self, val* p0, long p1))(var64->class->vft[COLOR_standard__array__Array__with_native]))(var64, var66, var65) /* with_native on */; -} -} -{ -var67 = ((val* (*)(val* self))(var64->class->vft[COLOR_standard__string__Object__to_s]))(var64) /* to_s on */; -} -{ -nit___nit__AbstractCompilerVisitor___add(self, var67); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +goto BREAK_label; } -var = var_res; -goto RET_LABEL; -} else { -var = var_value; -goto RET_LABEL; } +BREAK_label: (void)0; RET_LABEL:; -return var; }