X-Git-Url: http://nitlanguage.org diff --git a/c_src/rapid_type_analysis.sep.1.c b/c_src/rapid_type_analysis.sep.1.c index 0a38b8e..4477cb9 100644 --- a/c_src/rapid_type_analysis.sep.1.c +++ b/c_src/rapid_type_analysis.sep.1.c @@ -31,7 +31,7 @@ val* var1 /* : ModelBuilder */; var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dmodelbuilder].val; /* @modelbuilder on */ if (var1 == NULL) { fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @modelbuilder"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 43); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 46); show_backtrace(1); } var = var1; @@ -64,7 +64,7 @@ val* var1 /* : MModule */; var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dmainmodule].val; /* @mainmodule on */ if (var1 == NULL) { fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @mainmodule"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 46); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 49); show_backtrace(1); } var = var1; @@ -97,7 +97,7 @@ val* var1 /* : HashSet[MClassType] */; var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_types].val; /* @live_types on */ if (var1 == NULL) { fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @live_types"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 50); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 53); show_backtrace(1); } var = var1; @@ -130,7 +130,7 @@ val* var1 /* : HashSet[MClassType] */; var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_open_types].val; /* @live_open_types on */ if (var1 == NULL) { fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @live_open_types"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 55); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 58); show_backtrace(1); } var = var1; @@ -163,7 +163,7 @@ val* var1 /* : HashSet[MClass] */; var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_classes].val; /* @live_classes on */ if (var1 == NULL) { fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @live_classes"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 59); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 62); show_backtrace(1); } var = var1; @@ -189,35 +189,35 @@ void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_classes_61d(val* self, rapid_type_analysis__RapidTypeAnalysis__live_classes_61d(self, p0); RET_LABEL:; } -/* method rapid_type_analysis#RapidTypeAnalysis#live_cast_types for (self: RapidTypeAnalysis): HashSet[MClassType] */ +/* method rapid_type_analysis#RapidTypeAnalysis#live_cast_types for (self: RapidTypeAnalysis): HashSet[MType] */ val* rapid_type_analysis__RapidTypeAnalysis__live_cast_types(val* self) { -val* var /* : HashSet[MClassType] */; -val* var1 /* : HashSet[MClassType] */; +val* var /* : HashSet[MType] */; +val* var1 /* : HashSet[MType] */; var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_cast_types].val; /* @live_cast_types on */ if (var1 == NULL) { fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @live_cast_types"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 62); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 65); show_backtrace(1); } var = var1; RET_LABEL:; return var; } -/* method rapid_type_analysis#RapidTypeAnalysis#live_cast_types for (self: Object): HashSet[MClassType] */ +/* method rapid_type_analysis#RapidTypeAnalysis#live_cast_types for (self: Object): HashSet[MType] */ val* VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_cast_types(val* self) { -val* var /* : HashSet[MClassType] */; -val* var1 /* : HashSet[MClassType] */; +val* var /* : HashSet[MType] */; +val* var1 /* : HashSet[MType] */; var1 = rapid_type_analysis__RapidTypeAnalysis__live_cast_types(self); var = var1; RET_LABEL:; return var; } -/* method rapid_type_analysis#RapidTypeAnalysis#live_cast_types= for (self: RapidTypeAnalysis, HashSet[MClassType]) */ +/* method rapid_type_analysis#RapidTypeAnalysis#live_cast_types= for (self: RapidTypeAnalysis, HashSet[MType]) */ void rapid_type_analysis__RapidTypeAnalysis__live_cast_types_61d(val* self, val* p0) { self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_cast_types].val = p0; /* @live_cast_types on */ RET_LABEL:; } -/* method rapid_type_analysis#RapidTypeAnalysis#live_cast_types= for (self: Object, HashSet[MClassType]) */ +/* method rapid_type_analysis#RapidTypeAnalysis#live_cast_types= for (self: Object, HashSet[MType]) */ void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_cast_types_61d(val* self, val* p0) { rapid_type_analysis__RapidTypeAnalysis__live_cast_types_61d(self, p0); RET_LABEL:; @@ -229,7 +229,7 @@ val* var1 /* : HashSet[MType] */; var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_open_cast_types].val; /* @live_open_cast_types on */ if (var1 == NULL) { fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @live_open_cast_types"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 65); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 68); show_backtrace(1); } var = var1; @@ -262,7 +262,7 @@ val* var1 /* : HashSet[MMethodDef] */; var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_methoddefs].val; /* @live_methoddefs on */ if (var1 == NULL) { fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @live_methoddefs"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 69); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 72); show_backtrace(1); } var = var1; @@ -295,7 +295,7 @@ val* var1 /* : HashSet[MMethod] */; var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_methods].val; /* @live_methods on */ if (var1 == NULL) { fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @live_methods"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 72); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 75); show_backtrace(1); } var = var1; @@ -328,7 +328,7 @@ val* var1 /* : HashSet[MMethodDef] */; var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_super_sends].val; /* @live_super_sends on */ if (var1 == NULL) { fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @live_super_sends"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 75); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 78); show_backtrace(1); } var = var1; @@ -354,6 +354,424 @@ void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_super_sends_61d(val* s rapid_type_analysis__RapidTypeAnalysis__live_super_sends_61d(self, p0); RET_LABEL:; } +/* method rapid_type_analysis#RapidTypeAnalysis#live_types_to_csv for (self: RapidTypeAnalysis): CSVDocument */ +val* rapid_type_analysis__RapidTypeAnalysis__live_types_to_csv(val* self) { +val* var /* : CSVDocument */; +val* var1 /* : HashSet[MType] */; +val* var_typeset /* var typeset: HashSet[MType] */; +val* var2 /* : HashSet[MClassType] */; +val* var3 /* : HashSet[MClassType] */; +val* var4 /* : HashSet[MType] */; +val* var5 /* : HashSet[MType] */; +val* var6 /* : Array[nullable Object] */; +val* var_types /* var types: Array[MType] */; +val* var7 /* : CachedAlphaComparator */; +val* var8 /* : CSVDocument */; +val* var_res /* var res: CSVDocument */; +static val* varonce; +val* var9 /* : String */; +char* var10 /* : NativeString */; +long var11 /* : Int */; +val* var12 /* : String */; +static val* varonce13; +val* var14 /* : String */; +char* var15 /* : NativeString */; +long var16 /* : Int */; +val* var17 /* : String */; +static val* varonce18; +val* var19 /* : String */; +char* var20 /* : NativeString */; +long var21 /* : Int */; +val* var22 /* : String */; +static val* varonce23; +val* var24 /* : String */; +char* var25 /* : NativeString */; +long var26 /* : Int */; +val* var27 /* : String */; +val* var28 /* : Array[String] */; +long var29 /* : Int */; +val* var30 /* : NativeArray[String] */; +val* var31 /* : Iterator[nullable Object] */; +short int var32 /* : Bool */; +val* var33 /* : nullable Object */; +val* var_t /* var t: MType */; +short int var34 /* : Bool */; +static val* varonce35; +val* var36 /* : String */; +char* var37 /* : NativeString */; +long var38 /* : Int */; +val* var39 /* : String */; +val* var_reso /* var reso: nullable Object */; +static val* varonce40; +val* var41 /* : String */; +char* var42 /* : NativeString */; +long var43 /* : Int */; +val* var44 /* : String */; +short int var45 /* : Bool */; +short int var46 /* : Bool */; +int cltype; +int idtype; +short int var47 /* : Bool */; +val* var48 /* : HashSet[MClassType] */; +short int var49 /* : Bool */; +val* var50 /* : HashSet[MClassType] */; +short int var51 /* : Bool */; +static val* varonce52; +val* var53 /* : String */; +char* var54 /* : NativeString */; +long var55 /* : Int */; +val* var56 /* : String */; +val* var_live /* var live: nullable Object */; +static val* varonce57; +val* var58 /* : String */; +char* var59 /* : NativeString */; +long var60 /* : Int */; +val* var61 /* : String */; +short int var62 /* : Bool */; +val* var63 /* : HashSet[MType] */; +short int var64 /* : Bool */; +val* var65 /* : HashSet[MType] */; +short int var66 /* : Bool */; +static val* varonce67; +val* var68 /* : String */; +char* var69 /* : NativeString */; +long var70 /* : Int */; +val* var71 /* : String */; +val* var_cast /* var cast: nullable Object */; +static val* varonce72; +val* var73 /* : String */; +char* var74 /* : NativeString */; +long var75 /* : Int */; +val* var76 /* : String */; +val* var77 /* : Array[Object] */; +long var78 /* : Int */; +val* var79 /* : NativeArray[Object] */; +var1 = NEW_hash_collection__HashSet(&type_hash_collection__HashSetmodel__MType); +((void (*)(val*))(var1->class->vft[COLOR_hash_collection__HashSet__init]))(var1) /* init on */; +var_typeset = var1; +var2 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_types]))(self) /* live_types on */; +((void (*)(val*, val*))(var_typeset->class->vft[COLOR_abstract_collection__SimpleCollection__add_all]))(var_typeset, var2) /* add_all on */; +var3 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_open_types]))(self) /* live_open_types on */; +((void (*)(val*, val*))(var_typeset->class->vft[COLOR_abstract_collection__SimpleCollection__add_all]))(var_typeset, var3) /* add_all on */; +var4 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_cast_types]))(self) /* live_cast_types on */; +((void (*)(val*, val*))(var_typeset->class->vft[COLOR_abstract_collection__SimpleCollection__add_all]))(var_typeset, var4) /* add_all on */; +var5 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_open_cast_types]))(self) /* live_open_cast_types on */; +((void (*)(val*, val*))(var_typeset->class->vft[COLOR_abstract_collection__SimpleCollection__add_all]))(var_typeset, var5) /* add_all on */; +var6 = ((val* (*)(val*))(var_typeset->class->vft[COLOR_array__Collection__to_a]))(var_typeset) /* to_a on */; +var_types = var6; +var7 = NEW_string__CachedAlphaComparator(&type_string__CachedAlphaComparator); +((void (*)(val*))(var7->class->vft[COLOR_string__CachedAlphaComparator__init]))(var7) /* init on */; +((void (*)(val*, val*))(var7->class->vft[COLOR_sorter__AbstractSorter__sort]))(var7, var_types) /* sort on */; +var8 = NEW_csv__CSVDocument(&type_csv__CSVDocument); +((void (*)(val*))(var8->class->vft[COLOR_csv__CSVDocument__init]))(var8) /* init on */; +var_res = var8; +if (varonce) { +var9 = varonce; +} else { +var10 = "Type"; +var11 = 4; +var12 = string__NativeString__to_s_with_length(var10, var11); +var9 = var12; +varonce = var9; +} +if (varonce13) { +var14 = varonce13; +} else { +var15 = "Resolution"; +var16 = 10; +var17 = string__NativeString__to_s_with_length(var15, var16); +var14 = var17; +varonce13 = var14; +} +if (varonce18) { +var19 = varonce18; +} else { +var20 = "Liveness"; +var21 = 8; +var22 = string__NativeString__to_s_with_length(var20, var21); +var19 = var22; +varonce18 = var19; +} +if (varonce23) { +var24 = varonce23; +} else { +var25 = "Cast-liveness"; +var26 = 13; +var27 = string__NativeString__to_s_with_length(var25, var26); +var24 = var27; +varonce23 = var24; +} +var28 = NEW_array__Array(&type_array__Arraystring__String); +{ /* var28 = array_instance Array[String] */ +var29 = 4; +var30 = NEW_array__NativeArray(var29, &type_array__NativeArraystring__String); +((struct instance_array__NativeArray*)var30)->values[0] = (val*) var9; +((struct instance_array__NativeArray*)var30)->values[1] = (val*) var14; +((struct instance_array__NativeArray*)var30)->values[2] = (val*) var19; +((struct instance_array__NativeArray*)var30)->values[3] = (val*) var24; +((void (*)(val*, val*, long))(var28->class->vft[COLOR_array__Array__with_native]))(var28, var30, var29) /* with_native on */; +} +((void (*)(val*, val*))(var_res->class->vft[COLOR_csv__CSVDocument__header_61d]))(var_res, var28) /* header= on */; +var31 = ((val* (*)(val*))(var_types->class->vft[COLOR_abstract_collection__Collection__iterator]))(var_types) /* iterator on */; +for(;;) { +var32 = ((short int (*)(val*))(var31->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var31) /* is_ok on */; +if(!var32) break; +var33 = ((val* (*)(val*))(var31->class->vft[COLOR_abstract_collection__Iterator__item]))(var31) /* item on */; +var_t = var33; +var34 = ((short int (*)(val*))(var_t->class->vft[COLOR_model__MType__need_anchor]))(var_t) /* need_anchor on */; +if (var34){ +if (varonce35) { +var36 = varonce35; +} else { +var37 = "OPEN "; +var38 = 5; +var39 = string__NativeString__to_s_with_length(var37, var38); +var36 = var39; +varonce35 = var36; +} +var_reso = var36; +} else { +if (varonce40) { +var41 = varonce40; +} else { +var42 = "CLOSED"; +var43 = 6; +var44 = string__NativeString__to_s_with_length(var42, var43); +var41 = var44; +varonce40 = var41; +} +var_reso = var41; +} +/* isa MClassType */ +cltype = type_model__MClassType.color; +idtype = type_model__MClassType.id; +if(cltype >= var_t->type->table_size) { +var46 = 0; +} else { +var46 = var_t->type->type_table[cltype] == idtype; +} +if (!var46) { +var45 = 0; +} else { +var48 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_types]))(self) /* live_types on */; +var49 = ((short int (*)(val*, val*))(var48->class->vft[COLOR_abstract_collection__Collection__has]))(var48, var_t) /* has on */; +if (var49) { +var47 = 1; +} else { +var50 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_open_types]))(self) /* live_open_types on */; +var51 = ((short int (*)(val*, val*))(var50->class->vft[COLOR_abstract_collection__Collection__has]))(var50, var_t) /* has on */; +var47 = var51; +} +var45 = var47; +} +if (var45){ +if (varonce52) { +var53 = varonce52; +} else { +var54 = "LIVE"; +var55 = 4; +var56 = string__NativeString__to_s_with_length(var54, var55); +var53 = var56; +varonce52 = var53; +} +var_live = var53; +} else { +if (varonce57) { +var58 = varonce57; +} else { +var59 = "DEAD"; +var60 = 4; +var61 = string__NativeString__to_s_with_length(var59, var60); +var58 = var61; +varonce57 = var58; +} +var_live = var58; +} +var63 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_cast_types]))(self) /* live_cast_types on */; +var64 = ((short int (*)(val*, val*))(var63->class->vft[COLOR_abstract_collection__Collection__has]))(var63, var_t) /* has on */; +if (var64) { +var62 = 1; +} else { +var65 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_open_cast_types]))(self) /* live_open_cast_types on */; +var66 = ((short int (*)(val*, val*))(var65->class->vft[COLOR_abstract_collection__Collection__has]))(var65, var_t) /* has on */; +var62 = var66; +} +if (var62){ +if (varonce67) { +var68 = varonce67; +} else { +var69 = "CAST LIVE"; +var70 = 9; +var71 = string__NativeString__to_s_with_length(var69, var70); +var68 = var71; +varonce67 = var68; +} +var_cast = var68; +} else { +if (varonce72) { +var73 = varonce72; +} else { +var74 = "CAST DEAD"; +var75 = 9; +var76 = string__NativeString__to_s_with_length(var74, var75); +var73 = var76; +varonce72 = var73; +} +var_cast = var73; +} +var77 = NEW_array__Array(&type_array__Arraykernel__Object); +{ /* var77 = array_instance Array[Object] */ +var78 = 4; +var79 = NEW_array__NativeArray(var78, &type_array__NativeArraykernel__Object); +((struct instance_array__NativeArray*)var79)->values[0] = (val*) var_t; +((struct instance_array__NativeArray*)var79)->values[1] = (val*) var_reso; +((struct instance_array__NativeArray*)var79)->values[2] = (val*) var_live; +((struct instance_array__NativeArray*)var79)->values[3] = (val*) var_cast; +((void (*)(val*, val*, long))(var77->class->vft[COLOR_array__Array__with_native]))(var77, var79, var78) /* with_native on */; +} +((void (*)(val*, val*))(var_res->class->vft[COLOR_csv__CSVDocument__add_line]))(var_res, var77) /* add_line on */; +CONTINUE_label: (void)0; +((void (*)(val*))(var31->class->vft[COLOR_abstract_collection__Iterator__next]))(var31) /* next on */; +} +BREAK_label: (void)0; +var = var_res; +goto RET_LABEL; +RET_LABEL:; +return var; +} +/* method rapid_type_analysis#RapidTypeAnalysis#live_types_to_csv for (self: Object): CSVDocument */ +val* VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_types_to_csv(val* self) { +val* var /* : CSVDocument */; +val* var1 /* : CSVDocument */; +var1 = rapid_type_analysis__RapidTypeAnalysis__live_types_to_csv(self); +var = var1; +RET_LABEL:; +return var; +} +/* method rapid_type_analysis#RapidTypeAnalysis#live_methods_to_tree for (self: RapidTypeAnalysis): OrderedTree[Object] */ +val* rapid_type_analysis__RapidTypeAnalysis__live_methods_to_tree(val* self) { +val* var /* : OrderedTree[Object] */; +val* var1 /* : OrderedTree[Object] */; +val* var_tree /* var tree: OrderedTree[Object] */; +val* var2 /* : HashSet[MMethod] */; +val* var3 /* : Iterator[nullable Object] */; +short int var4 /* : Bool */; +val* var5 /* : nullable Object */; +val* var_x /* var x: MMethod */; +val* var6 /* : String */; +val* var_xn /* var xn: String */; +val* var7 /* : null */; +val* var8 /* : Array[MPropDef] */; +val* var9 /* : Iterator[nullable Object] */; +short int var10 /* : Bool */; +val* var11 /* : nullable Object */; +val* var_z /* var z: MMethodDef */; +val* var12 /* : String */; +val* var_zn /* var zn: String */; +val* var13 /* : HashSet[MMethodDef] */; +short int var14 /* : Bool */; +val* var15 /* : HashSet[MMethodDef] */; +short int var16 /* : Bool */; +static val* varonce; +val* var17 /* : String */; +char* var18 /* : NativeString */; +long var19 /* : Int */; +val* var20 /* : String */; +val* var21 /* : String */; +val* var22 /* : HashSet[MMethodDef] */; +short int var23 /* : Bool */; +static val* varonce24; +val* var25 /* : String */; +char* var26 /* : NativeString */; +long var27 /* : Int */; +val* var28 /* : String */; +val* var29 /* : String */; +val* var31 /* : AbstractSorter[Object] */; +var1 = NEW_ordered_tree__OrderedTree(&type_ordered_tree__OrderedTreekernel__Object); +((void (*)(val*))(var1->class->vft[COLOR_ordered_tree__OrderedTree__init]))(var1) /* init on */; +var_tree = var1; +var2 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_methods]))(self) /* live_methods on */; +var3 = ((val* (*)(val*))(var2->class->vft[COLOR_abstract_collection__Collection__iterator]))(var2) /* iterator on */; +for(;;) { +var4 = ((short int (*)(val*))(var3->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var3) /* is_ok on */; +if(!var4) break; +var5 = ((val* (*)(val*))(var3->class->vft[COLOR_abstract_collection__Iterator__item]))(var3) /* item on */; +var_x = var5; +var6 = ((val* (*)(val*))(var_x->class->vft[COLOR_model__MProperty__full_name]))(var_x) /* full_name on */; +var_xn = var6; +var7 = NULL; +((void (*)(val*, val*, val*))(var_tree->class->vft[COLOR_ordered_tree__OrderedTree__add]))(var_tree, var7, var_xn) /* add on */; +var8 = ((val* (*)(val*))(var_x->class->vft[COLOR_model__MProperty__mpropdefs]))(var_x) /* mpropdefs on */; +var9 = ((val* (*)(val*))(var8->class->vft[COLOR_abstract_collection__Collection__iterator]))(var8) /* iterator on */; +for(;;) { +var10 = ((short int (*)(val*))(var9->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var9) /* is_ok on */; +if(!var10) break; +var11 = ((val* (*)(val*))(var9->class->vft[COLOR_abstract_collection__Iterator__item]))(var9) /* item on */; +var_z = var11; +var12 = ((val* (*)(val*))(var_z->class->vft[COLOR_string__Object__to_s]))(var_z) /* to_s on */; +var_zn = var12; +var13 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_methoddefs]))(self) /* live_methoddefs on */; +var14 = ((short int (*)(val*, val*))(var13->class->vft[COLOR_abstract_collection__Collection__has]))(var13, var_z) /* has on */; +if (var14){ +((void (*)(val*, val*, val*))(var_tree->class->vft[COLOR_ordered_tree__OrderedTree__add]))(var_tree, var_xn, var_zn) /* add on */; +var15 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_super_sends]))(self) /* live_super_sends on */; +var16 = ((short int (*)(val*, val*))(var15->class->vft[COLOR_abstract_collection__Collection__has]))(var15, var_z) /* has on */; +if (var16){ +if (varonce) { +var17 = varonce; +} else { +var18 = "(super)"; +var19 = 7; +var20 = string__NativeString__to_s_with_length(var18, var19); +var17 = var20; +varonce = var17; +} +var21 = ((val* (*)(val*, val*))(var_zn->class->vft[COLOR_string__String___43d]))(var_zn, var17) /* + on */; +((void (*)(val*, val*, val*))(var_tree->class->vft[COLOR_ordered_tree__OrderedTree__add]))(var_tree, var_zn, var21) /* add on */; +} else { +} +} else { +var22 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_super_sends]))(self) /* live_super_sends on */; +var23 = ((short int (*)(val*, val*))(var22->class->vft[COLOR_abstract_collection__Collection__has]))(var22, var_z) /* has on */; +if (var23){ +if (varonce24) { +var25 = varonce24; +} else { +var26 = "(super)"; +var27 = 7; +var28 = string__NativeString__to_s_with_length(var26, var27); +var25 = var28; +varonce24 = var25; +} +var29 = ((val* (*)(val*, val*))(var_zn->class->vft[COLOR_string__String___43d]))(var_zn, var25) /* + on */; +((void (*)(val*, val*, val*))(var_tree->class->vft[COLOR_ordered_tree__OrderedTree__add]))(var_tree, var_xn, var29) /* add on */; +} else { +} +} +CONTINUE_label: (void)0; +((void (*)(val*))(var9->class->vft[COLOR_abstract_collection__Iterator__next]))(var9) /* next on */; +} +BREAK_label: (void)0; +CONTINUE_label30: (void)0; +((void (*)(val*))(var3->class->vft[COLOR_abstract_collection__Iterator__next]))(var3) /* next on */; +} +BREAK_label30: (void)0; +var31 = ((val* (*)(val*))(self->class->vft[COLOR_string__Object__alpha_comparator]))(self) /* alpha_comparator on */; +((void (*)(val*, val*))(var_tree->class->vft[COLOR_ordered_tree__OrderedTree__sort_with]))(var_tree, var31) /* sort_with on */; +var = var_tree; +goto RET_LABEL; +RET_LABEL:; +return var; +} +/* method rapid_type_analysis#RapidTypeAnalysis#live_methods_to_tree for (self: Object): OrderedTree[Object] */ +val* VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_methods_to_tree(val* self) { +val* var /* : OrderedTree[Object] */; +val* var1 /* : OrderedTree[Object] */; +var1 = rapid_type_analysis__RapidTypeAnalysis__live_methods_to_tree(self); +var = var1; +RET_LABEL:; +return var; +} /* method rapid_type_analysis#RapidTypeAnalysis#totry_methods for (self: RapidTypeAnalysis): HashSet[MMethod] */ val* rapid_type_analysis__RapidTypeAnalysis__totry_methods(val* self) { val* var /* : HashSet[MMethod] */; @@ -361,7 +779,7 @@ val* var1 /* : HashSet[MMethod] */; var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dtotry_methods].val; /* @totry_methods on */ if (var1 == NULL) { fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @totry_methods"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 78); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 132); show_backtrace(1); } var = var1; @@ -394,7 +812,7 @@ val* var1 /* : List[MMethodDef] */; var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dtodo].val; /* @todo on */ if (var1 == NULL) { fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @todo"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 81); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 135); show_backtrace(1); } var = var1; @@ -420,6 +838,55 @@ void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__todo_61d(val* self, val* p0 rapid_type_analysis__RapidTypeAnalysis__todo_61d(self, p0); RET_LABEL:; } +/* method rapid_type_analysis#RapidTypeAnalysis#force_alive for (self: RapidTypeAnalysis, String) */ +void rapid_type_analysis__RapidTypeAnalysis__force_alive(val* self, val* p0) { +val* var_classname /* var classname: String */; +val* var /* : ModelBuilder */; +val* var1 /* : Model */; +val* var2 /* : nullable Array[MClass] */; +val* var_classes /* var classes: nullable Array[MClass] */; +val* var3 /* : null */; +short int var4 /* : Bool */; +val* var5 /* : Iterator[nullable Object] */; +short int var6 /* : Bool */; +val* var7 /* : nullable Object */; +val* var_c /* var c: MClass */; +val* var8 /* : MClassType */; +val* var9 /* : MClassType */; +var_classname = p0; +var = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__modelbuilder]))(self) /* modelbuilder on */; +var1 = ((val* (*)(val*))(var->class->vft[COLOR_modelbuilder__ModelBuilder__model]))(var) /* model on */; +var2 = ((val* (*)(val*, val*))(var1->class->vft[COLOR_model__Model__get_mclasses_by_name]))(var1, var_classname) /* get_mclasses_by_name on */; +var_classes = var2; +var3 = NULL; +if (var_classes == NULL) { +var4 = 0; /* is null */ +} else { +var4 = 1; /* arg is null and recv is not */ +} +if (var4){ +var5 = ((val* (*)(val*))(var_classes->class->vft[COLOR_abstract_collection__Collection__iterator]))(var_classes) /* iterator on */; +for(;;) { +var6 = ((short int (*)(val*))(var5->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var5) /* is_ok on */; +if(!var6) break; +var7 = ((val* (*)(val*))(var5->class->vft[COLOR_abstract_collection__Iterator__item]))(var5) /* item on */; +var_c = var7; +var8 = ((val* (*)(val*))(var_c->class->vft[COLOR_model__MClass__mclass_type]))(var_c) /* mclass_type on */; +var9 = ((val* (*)(val*))(var_c->class->vft[COLOR_model__MClass__mclass_type]))(var_c) /* mclass_type on */; +((void (*)(val*, val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__add_new]))(self, var8, var9) /* add_new on */; +CONTINUE_label: (void)0; +((void (*)(val*))(var5->class->vft[COLOR_abstract_collection__Iterator__next]))(var5) /* next on */; +} +BREAK_label: (void)0; +} else { +} +RET_LABEL:; +} +/* method rapid_type_analysis#RapidTypeAnalysis#force_alive for (self: Object, String) */ +void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__force_alive(val* self, val* p0) { +rapid_type_analysis__RapidTypeAnalysis__force_alive(self, p0); +RET_LABEL:; +} /* method rapid_type_analysis#RapidTypeAnalysis#run_analysis for (self: RapidTypeAnalysis) */ void rapid_type_analysis__RapidTypeAnalysis__run_analysis(val* self) { val* var /* : MModule */; @@ -449,247 +916,242 @@ val* var20 /* : nullable MMethod */; val* var_mainprop /* var mainprop: nullable MMethod */; val* var21 /* : null */; short int var22 /* : Bool */; -val* var23 /* : ModelBuilder */; -val* var24 /* : Model */; -static val* varonce25; -val* var26 /* : String */; -char* var27 /* : NativeString */; -long var28 /* : Int */; +static val* varonce23; +val* var24 /* : String */; +char* var25 /* : NativeString */; +long var26 /* : Int */; +val* var27 /* : String */; +static val* varonce28; val* var29 /* : String */; -val* var30 /* : nullable Array[MClass] */; -val* var_classes /* var classes: nullable Array[MClass] */; -val* var31 /* : null */; -short int var32 /* : Bool */; -val* var33 /* : Iterator[nullable Object] */; -short int var34 /* : Bool */; -val* var35 /* : nullable Object */; -val* var_c /* var c: MClass */; -val* var36 /* : MClassType */; -val* var37 /* : MClassType */; -val* var38 /* : List[MMethodDef] */; -short int var39 /* : Bool */; -short int var40 /* : Bool */; -val* var41 /* : List[MMethodDef] */; -val* var42 /* : nullable Object */; +char* var30 /* : NativeString */; +long var31 /* : Int */; +val* var32 /* : String */; +static val* varonce33; +val* var34 /* : String */; +char* var35 /* : NativeString */; +long var36 /* : Int */; +val* var37 /* : String */; +static val* varonce38; +val* var39 /* : String */; +char* var40 /* : NativeString */; +long var41 /* : Int */; +val* var42 /* : String */; +val* var43 /* : List[MMethodDef] */; +short int var44 /* : Bool */; +short int var45 /* : Bool */; +val* var46 /* : List[MMethodDef] */; +val* var47 /* : nullable Object */; val* var_mmethoddef /* var mmethoddef: MMethodDef */; -val* var43 /* : RapidTypeVisitor */; -val* var44 /* : MClassDef */; -val* var45 /* : MClassType */; +val* var48 /* : RapidTypeVisitor */; +val* var49 /* : MClassDef */; +val* var50 /* : MClassType */; val* var_v /* var v: RapidTypeVisitor */; -val* var46 /* : nullable MSignature */; -long var47 /* : Int */; +val* var51 /* : nullable MSignature */; +long var52 /* : Int */; long var_vararg_rank /* var vararg_rank: Int */; -long var48 /* : Int */; -long var49 /* : Int */; -long var51 /* : Int */; -short int var52 /* : Bool */; -short int var54 /* : Bool */; +long var53 /* : Int */; +long var54 /* : Int */; +long var56 /* : Int */; +short int var57 /* : Bool */; +short int var59 /* : Bool */; int cltype; int idtype; const char* var_class_name; -short int var55 /* : Bool */; -val* var56 /* : ModelBuilder */; -val* var57 /* : HashMap[MPropDef, APropdef] */; -val* var58 /* : nullable Object */; +short int var60 /* : Bool */; +val* var61 /* : ModelBuilder */; +val* var62 /* : HashMap[MPropDef, APropdef] */; +val* var63 /* : nullable Object */; val* var_node /* var node: APropdef */; -val* var59 /* : nullable MSignature */; -val* var60 /* : Array[MParameter] */; -val* var61 /* : nullable Object */; -val* var62 /* : MType */; +val* var64 /* : nullable MSignature */; +val* var65 /* : Array[MParameter] */; +val* var66 /* : nullable Object */; +val* var67 /* : MType */; val* var_elttype /* var elttype: MType */; -val* var63 /* : MModule */; -static val* varonce64; -val* var65 /* : String */; -char* var66 /* : NativeString */; -long var67 /* : Int */; -val* var68 /* : String */; -val* var69 /* : MClass */; -val* var70 /* : Array[MType] */; -long var71 /* : Int */; -val* var72 /* : NativeArray[MType] */; -val* var73 /* : MClassType */; +val* var68 /* : MModule */; +static val* varonce69; +val* var70 /* : String */; +char* var71 /* : NativeString */; +long var72 /* : Int */; +val* var73 /* : String */; +val* var74 /* : MClass */; +val* var75 /* : Array[MType] */; +long var76 /* : Int */; +val* var77 /* : NativeArray[MType] */; +val* var78 /* : MClassType */; val* var_vararg /* var vararg: MClassType */; -val* var74 /* : MModule */; -static val* varonce75; -val* var76 /* : String */; -char* var77 /* : NativeString */; -long var78 /* : Int */; -val* var79 /* : String */; -val* var80 /* : MClass */; -val* var81 /* : Array[MType] */; -long var82 /* : Int */; -val* var83 /* : NativeArray[MType] */; -val* var84 /* : MClassType */; +val* var79 /* : MModule */; +static val* varonce80; +val* var81 /* : String */; +char* var82 /* : NativeString */; +long var83 /* : Int */; +val* var84 /* : String */; +val* var85 /* : MClass */; +val* var86 /* : Array[MType] */; +long var87 /* : Int */; +val* var88 /* : NativeArray[MType] */; +val* var89 /* : MClassType */; val* var_native /* var native: MClassType */; -val* var85 /* : ModelBuilder */; -static val* varonce86; -val* var87 /* : String */; -char* var88 /* : NativeString */; -long var89 /* : Int */; -val* var90 /* : String */; -val* var91 /* : MClass */; -val* var92 /* : MModule */; -val* var93 /* : MMethod */; -val* var94 /* : Range[Int] */; -long var95 /* : Int */; -val* var96 /* : nullable MSignature */; -long var97 /* : Int */; -val* var98 /* : Discrete */; -val* var99 /* : Discrete */; -val* var100 /* : Iterator[nullable Object] */; -short int var101 /* : Bool */; -val* var102 /* : nullable Object */; +val* var90 /* : ModelBuilder */; +static val* varonce91; +val* var92 /* : String */; +char* var93 /* : NativeString */; +long var94 /* : Int */; +val* var95 /* : String */; +val* var96 /* : MClass */; +val* var97 /* : MModule */; +val* var98 /* : MMethod */; +val* var99 /* : Range[Int] */; +long var100 /* : Int */; +val* var101 /* : nullable MSignature */; +long var102 /* : Int */; +val* var103 /* : Discrete */; +val* var104 /* : Discrete */; +val* var105 /* : Iterator[nullable Object] */; +short int var106 /* : Bool */; +val* var107 /* : nullable Object */; long var_i /* var i: Int */; -long var103 /* : Int */; -val* var104 /* : MProperty */; -val* var105 /* : MPropDef */; -val* var106 /* : nullable MSignature */; -val* var107 /* : Array[MParameter] */; -val* var108 /* : nullable Object */; -val* var109 /* : MType */; +long var108 /* : Int */; +val* var109 /* : MProperty */; +val* var110 /* : MPropDef */; +val* var111 /* : nullable MSignature */; +val* var112 /* : Array[MParameter] */; +val* var113 /* : nullable Object */; +val* var114 /* : MType */; val* var_origtype /* var origtype: MType */; -short int var110 /* : Bool */; -short int var111 /* : Bool */; -val* var113 /* : nullable MSignature */; -val* var114 /* : Array[MParameter] */; -val* var115 /* : nullable Object */; -val* var116 /* : MType */; +short int var115 /* : Bool */; +short int var116 /* : Bool */; +val* var117 /* : nullable MSignature */; +val* var118 /* : Array[MParameter] */; +val* var119 /* : nullable Object */; +val* var120 /* : MType */; val* var_paramtype /* var paramtype: MType */; -val* var117 /* : ModelBuilder */; -val* var118 /* : HashMap[MPropDef, APropdef] */; -short int var119 /* : Bool */; -short int var120 /* : Bool */; -val* var121 /* : MProperty */; -val* var122 /* : String */; -static val* varonce123; -val* var124 /* : String */; -char* var125 /* : NativeString */; -long var126 /* : Int */; -val* var127 /* : String */; -short int var128 /* : Bool */; -val* var129 /* : ModelBuilder */; -val* var130 /* : HashMap[MClassDef, AClassdef] */; -val* var131 /* : MClassDef */; -val* var132 /* : nullable Object */; +val* var121 /* : ModelBuilder */; +val* var122 /* : HashMap[MPropDef, APropdef] */; +short int var123 /* : Bool */; +short int var124 /* : Bool */; +val* var125 /* : MProperty */; +val* var126 /* : String */; +static val* varonce127; +val* var128 /* : String */; +char* var129 /* : NativeString */; +long var130 /* : Int */; +val* var131 /* : String */; +short int var132 /* : Bool */; +val* var133 /* : ModelBuilder */; +val* var134 /* : HashMap[MClassDef, AClassdef] */; +val* var135 /* : MClassDef */; +val* var136 /* : nullable Object */; val* var_nclassdef /* var nclassdef: AClassdef */; -val* var133 /* : nullable Collection[MMethod] */; +val* var137 /* : nullable Collection[MMethod] */; val* var_super_inits /* var super_inits: nullable Collection[MMethod] */; -val* var134 /* : null */; -short int var135 /* : Bool */; -val* var136 /* : Iterator[nullable Object] */; -short int var137 /* : Bool */; -val* var138 /* : nullable Object */; +val* var138 /* : null */; +short int var139 /* : Bool */; +val* var140 /* : Iterator[nullable Object] */; +short int var141 /* : Bool */; +val* var142 /* : nullable Object */; val* var_su /* var su: MMethod */; -val* var139 /* : MClassType */; -val* var142 /* : ModelBuilder */; -val* var143 /* : HashMap[MPropDef, APropdef] */; -val* var144 /* : nullable Object */; +val* var143 /* : MClassType */; +val* var146 /* : ModelBuilder */; +val* var147 /* : HashMap[MPropDef, APropdef] */; +val* var148 /* : nullable Object */; val* var_npropdef /* var npropdef: APropdef */; -short int var145 /* : Bool */; -int cltype146; -int idtype147; -val* var148 /* : nullable Array[MMethod] */; -val* var_auto_super_inits /* var auto_super_inits: nullable Array[MMethod] */; -val* var149 /* : null */; -short int var150 /* : Bool */; -val* var151 /* : Iterator[nullable Object] */; -short int var152 /* : Bool */; -val* var153 /* : nullable Object */; -val* var_auto_super_init /* var auto_super_init: MMethod */; -val* var154 /* : MClassType */; +short int var149 /* : Bool */; +int cltype150; +int idtype151; +val* var152 /* : nullable Array[CallSite] */; +val* var_auto_super_inits /* var auto_super_inits: nullable Array[CallSite] */; +val* var153 /* : null */; +short int var154 /* : Bool */; +val* var155 /* : Iterator[nullable Object] */; short int var156 /* : Bool */; -short int var157 /* : Bool */; -int cltype158; -int idtype159; -short int var_ /* var : Bool */; +val* var157 /* : nullable Object */; +val* var_auto_super_init /* var auto_super_init: CallSite */; +short int var159 /* : Bool */; short int var160 /* : Bool */; -short int var161 /* : Bool */; -int cltype162; -int idtype163; -short int var_164 /* var : Bool */; -val* var165 /* : nullable TString */; -val* var166 /* : null */; -short int var167 /* : Bool */; -val* var168 /* : nullable MSignature */; -val* var169 /* : nullable MType */; -val* var_ret /* var ret: nullable MType */; +int cltype161; +int idtype162; +short int var_ /* var : Bool */; +short int var163 /* : Bool */; +short int var164 /* : Bool */; +int cltype165; +int idtype166; +short int var_167 /* var : Bool */; +val* var168 /* : nullable TString */; +val* var169 /* : null */; short int var170 /* : Bool */; -short int var171 /* : Bool */; -short int var172 /* : Bool */; -val* var173 /* : null */; +val* var171 /* : nullable MSignature */; +val* var172 /* : nullable MType */; +val* var_ret /* var ret: nullable MType */; +short int var173 /* : Bool */; short int var174 /* : Bool */; -short int var_175 /* var : Bool */; -short int var176 /* : Bool */; -int cltype177; -int idtype178; -short int var_179 /* var : Bool */; -val* var180 /* : MClass */; -val* var181 /* : MClassKind */; -val* var182 /* : MClassKind */; -short int var183 /* : Bool */; -short int var_184 /* var : Bool */; -val* var185 /* : MClass */; -val* var186 /* : MClassKind */; -val* var187 /* : MClassKind */; -short int var188 /* : Bool */; -short int var189 /* : Bool */; -int cltype190; -int idtype191; -val* var192 /* : nullable ANode */; -short int var193 /* : Bool */; -int cltype194; -int idtype195; -const char* var_class_name196; -val* var_nclassdef197 /* var nclassdef: AClassdef */; -short int var198 /* : Bool */; -int cltype199; -int idtype200; -val* var201 /* : MClassType */; -val* var202 /* : List[MClassType] */; +short int var175 /* : Bool */; +val* var176 /* : null */; +short int var177 /* : Bool */; +short int var_178 /* var : Bool */; +short int var179 /* : Bool */; +int cltype180; +int idtype181; +short int var_182 /* var : Bool */; +val* var183 /* : MClass */; +val* var184 /* : MClassKind */; +val* var185 /* : MClassKind */; +short int var186 /* : Bool */; +short int var_187 /* var : Bool */; +val* var188 /* : MClass */; +val* var189 /* : MClassKind */; +val* var190 /* : MClassKind */; +short int var191 /* : Bool */; +short int var192 /* : Bool */; +int cltype193; +int idtype194; +val* var195 /* : nullable ANode */; +short int var196 /* : Bool */; +int cltype197; +int idtype198; +const char* var_class_name199; +val* var_nclassdef200 /* var nclassdef: AClassdef */; +short int var201 /* : Bool */; +int cltype202; +int idtype203; +val* var204 /* : MClassType */; +val* var205 /* : List[MClassType] */; val* var_todo_types /* var todo_types: List[MClassType] */; -val* var203 /* : HashSet[MClassType] */; -short int var204 /* : Bool */; -short int var205 /* : Bool */; -val* var206 /* : nullable Object */; +val* var206 /* : HashSet[MClassType] */; +short int var207 /* : Bool */; +short int var208 /* : Bool */; +val* var209 /* : nullable Object */; val* var_t /* var t: MClassType */; -val* var207 /* : HashSet[MClassType] */; -val* var208 /* : Iterator[nullable Object] */; -short int var209 /* : Bool */; -val* var210 /* : nullable Object */; -val* var_ot /* var ot: MClassType */; -val* var211 /* : MModule */; +val* var210 /* : HashSet[MClassType] */; +val* var211 /* : Iterator[nullable Object] */; short int var212 /* : Bool */; -short int var213 /* : Bool */; -val* var215 /* : MModule */; -val* var216 /* : MType */; +val* var213 /* : nullable Object */; +val* var_ot /* var ot: MClassType */; +val* var214 /* : MModule */; +short int var215 /* : Bool */; +short int var216 /* : Bool */; +val* var218 /* : MModule */; +val* var219 /* : MType */; val* var_rt /* var rt: MClassType */; -val* var217 /* : HashSet[MClassType] */; -short int var218 /* : Bool */; -val* var219 /* : HashSet[MClassType] */; -val* var221 /* : HashSet[MType] */; -val* var222 /* : Iterator[nullable Object] */; -short int var223 /* : Bool */; -val* var224 /* : nullable Object */; -val* var_ot225 /* var ot: MType */; -val* var226 /* : HashSet[MClassType] */; -val* var227 /* : Iterator[nullable Object] */; -short int var228 /* : Bool */; -val* var229 /* : nullable Object */; -val* var_t230 /* var t: MClassType */; -val* var231 /* : MModule */; -short int var232 /* : Bool */; -short int var233 /* : Bool */; -val* var235 /* : MModule */; -val* var236 /* : MType */; -val* var_rt237 /* var rt: MType */; -short int var238 /* : Bool */; -int cltype239; -int idtype240; -val* var241 /* : MType */; -short int var242 /* : Bool */; -int cltype243; -int idtype244; -val* var245 /* : HashSet[MClassType] */; +val* var220 /* : HashSet[MClassType] */; +short int var221 /* : Bool */; +val* var222 /* : HashSet[MClassType] */; +val* var224 /* : HashSet[MType] */; +val* var225 /* : Iterator[nullable Object] */; +short int var226 /* : Bool */; +val* var227 /* : nullable Object */; +val* var_ot228 /* var ot: MType */; +val* var229 /* : HashSet[MClassType] */; +val* var230 /* : Iterator[nullable Object] */; +short int var231 /* : Bool */; +val* var232 /* : nullable Object */; +val* var_t233 /* var t: MClassType */; +val* var234 /* : MModule */; +short int var235 /* : Bool */; +short int var236 /* : Bool */; +val* var238 /* : MModule */; +val* var239 /* : MType */; +val* var_rt240 /* var rt: MType */; +val* var241 /* : HashSet[MType] */; var = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on */; var1 = ((val* (*)(val*))(var->class->vft[COLOR_model__MModule__sys_type]))(var) /* sys_type on */; var_maintype = var1; @@ -750,551 +1212,529 @@ if (var22){ ((void (*)(val*, val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__add_send]))(self, var_maintype, var_mainprop) /* add_send on */; } else { } -var23 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__modelbuilder]))(self) /* modelbuilder on */; -var24 = ((val* (*)(val*))(var23->class->vft[COLOR_modelbuilder__ModelBuilder__model]))(var23) /* model on */; -if (varonce25) { -var26 = varonce25; +if (varonce23) { +var24 = varonce23; } else { -var27 = "Bool"; -var28 = 4; -var29 = string__NativeString__to_s_with_length(var27, var28); -var26 = var29; -varonce25 = var26; +var25 = "Bool"; +var26 = 4; +var27 = string__NativeString__to_s_with_length(var25, var26); +var24 = var27; +varonce23 = var24; } -var30 = ((val* (*)(val*, val*))(var24->class->vft[COLOR_model__Model__get_mclasses_by_name]))(var24, var26) /* get_mclasses_by_name on */; -var_classes = var30; -var31 = NULL; -if (var_classes == NULL) { -var32 = 0; /* is null */ +((void (*)(val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__force_alive]))(self, var24) /* force_alive on */; +if (varonce28) { +var29 = varonce28; } else { -var32 = 1; /* arg is null and recv is not */ +var30 = "Int"; +var31 = 3; +var32 = string__NativeString__to_s_with_length(var30, var31); +var29 = var32; +varonce28 = var29; } -if (var32){ -var33 = ((val* (*)(val*))(var_classes->class->vft[COLOR_abstract_collection__Collection__iterator]))(var_classes) /* iterator on */; -for(;;) { -var34 = ((short int (*)(val*))(var33->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var33) /* is_ok on */; -if(!var34) break; -var35 = ((val* (*)(val*))(var33->class->vft[COLOR_abstract_collection__Iterator__item]))(var33) /* item on */; -var_c = var35; -var36 = ((val* (*)(val*))(var_c->class->vft[COLOR_model__MClass__mclass_type]))(var_c) /* mclass_type on */; -var37 = ((val* (*)(val*))(var_c->class->vft[COLOR_model__MClass__mclass_type]))(var_c) /* mclass_type on */; -((void (*)(val*, val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__add_new]))(self, var36, var37) /* add_new on */; -CONTINUE_label: (void)0; -((void (*)(val*))(var33->class->vft[COLOR_abstract_collection__Iterator__next]))(var33) /* next on */; +((void (*)(val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__force_alive]))(self, var29) /* force_alive on */; +if (varonce33) { +var34 = varonce33; +} else { +var35 = "Float"; +var36 = 5; +var37 = string__NativeString__to_s_with_length(var35, var36); +var34 = var37; +varonce33 = var34; } -BREAK_label: (void)0; +((void (*)(val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__force_alive]))(self, var34) /* force_alive on */; +if (varonce38) { +var39 = varonce38; } else { +var40 = "Char"; +var41 = 4; +var42 = string__NativeString__to_s_with_length(var40, var41); +var39 = var42; +varonce38 = var39; } +((void (*)(val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__force_alive]))(self, var39) /* force_alive on */; for(;;) { -var38 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__todo]))(self) /* todo on */; -var39 = ((short int (*)(val*))(var38->class->vft[COLOR_abstract_collection__Collection__is_empty]))(var38) /* is_empty on */; -var40 = !var39; -if (!var40) break; -var41 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__todo]))(self) /* todo on */; -var42 = ((val* (*)(val*))(var41->class->vft[COLOR_abstract_collection__Sequence__shift]))(var41) /* shift on */; -var_mmethoddef = var42; -var43 = NEW_rapid_type_analysis__RapidTypeVisitor(&type_rapid_type_analysis__RapidTypeVisitor); -var44 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MPropDef__mclassdef]))(var_mmethoddef) /* mclassdef on */; -var45 = ((val* (*)(val*))(var44->class->vft[COLOR_model__MClassDef__bound_mtype]))(var44) /* bound_mtype on */; -((void (*)(val*, val*, val*, val*))(var43->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__init]))(var43, self, var45, var_mmethoddef) /* init on */; -var_v = var43; -var46 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MMethodDef__msignature]))(var_mmethoddef) /* msignature on */; -if (var46 == NULL) { -fprintf(stderr, "Runtime error: %s", "Reciever is null"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 108); -show_backtrace(1); -} else { -var47 = ((long (*)(val*))(var46->class->vft[COLOR_model__MSignature__vararg_rank]))(var46) /* vararg_rank on */; -} -var_vararg_rank = var47; -var48 = 1; -{ /* Inline kernel#Int#unary - (var48) */ -var51 = -var48; -var49 = var51; -goto RET_LABEL50; -RET_LABEL50:(void)0; -} -{ /* Inline kernel#Int#> (var_vararg_rank,var49) */ -/* Covariant cast for argument 0 (i) isa OTHER */ -/* isa OTHER */ -var54 = 1; /* easy isa OTHER*/ -if (!var54) { +var43 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__todo]))(self) /* todo on */; +var44 = ((short int (*)(val*))(var43->class->vft[COLOR_abstract_collection__Collection__is_empty]))(var43) /* is_empty on */; +var45 = !var44; +if (!var45) break; +var46 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__todo]))(self) /* todo on */; +var47 = ((val* (*)(val*))(var46->class->vft[COLOR_abstract_collection__Sequence__shift]))(var46) /* shift on */; +var_mmethoddef = var47; +var48 = NEW_rapid_type_analysis__RapidTypeVisitor(&type_rapid_type_analysis__RapidTypeVisitor); +var49 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MPropDef__mclassdef]))(var_mmethoddef) /* mclassdef on */; +var50 = ((val* (*)(val*))(var49->class->vft[COLOR_model__MClassDef__bound_mtype]))(var49) /* bound_mtype on */; +((void (*)(val*, val*, val*, val*))(var48->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__init]))(var48, self, var50, var_mmethoddef) /* init on */; +var_v = var48; +var51 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MMethodDef__msignature]))(var_mmethoddef) /* msignature on */; +if (var51 == NULL) { +fprintf(stderr, "Runtime error: %s", "Receiver is null"); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 170); +show_backtrace(1); +} else { +var52 = ((long (*)(val*))(var51->class->vft[COLOR_model__MSignature__vararg_rank]))(var51) /* vararg_rank on */; +} +var_vararg_rank = var52; +var53 = 1; +{ /* Inline kernel#Int#unary - (var53) */ +var56 = -var53; +var54 = var56; +goto RET_LABEL55; +RET_LABEL55:(void)0; +} +{ /* Inline kernel#Int#> (var_vararg_rank,var54) */ +/* Covariant cast for argument 0 (i) isa OTHER */ +/* isa OTHER */ +var59 = 1; /* easy isa OTHER*/ +if (!var59) { var_class_name = type_kernel__Int.name; fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); -fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 263); -show_backtrace(1); -} -var55 = var_vararg_rank > var49; -var52 = var55; -goto RET_LABEL53; -RET_LABEL53:(void)0; -} -if (var52){ -var56 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__modelbuilder]))(self) /* modelbuilder on */; -var57 = ((val* (*)(val*))(var56->class->vft[COLOR_modelize_property__ModelBuilder__mpropdef2npropdef]))(var56) /* mpropdef2npropdef on */; -var58 = ((val* (*)(val*, val*))(var57->class->vft[COLOR_abstract_collection__MapRead___91d_93d]))(var57, var_mmethoddef) /* [] on */; -var_node = var58; -var59 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MMethodDef__msignature]))(var_mmethoddef) /* msignature on */; -if (var59 == NULL) { -fprintf(stderr, "Runtime error: %s", "Reciever is null"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 111); -show_backtrace(1); -} else { -var60 = ((val* (*)(val*))(var59->class->vft[COLOR_model__MSignature__mparameters]))(var59) /* mparameters on */; -} -var61 = ((val* (*)(val*, long))(var60->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var60, var_vararg_rank) /* [] on */; -var62 = ((val* (*)(val*))(var61->class->vft[COLOR_model__MParameter__mtype]))(var61) /* mtype on */; -var_elttype = var62; -var63 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on */; -if (varonce64) { -var65 = varonce64; -} else { -var66 = "Array"; -var67 = 5; -var68 = string__NativeString__to_s_with_length(var66, var67); -var65 = var68; -varonce64 = var65; -} -var69 = ((val* (*)(val*, val*))(var63->class->vft[COLOR_model__MModule__get_primitive_class]))(var63, var65) /* get_primitive_class on */; -var70 = NEW_array__Array(&type_array__Arraymodel__MType); -{ /* var70 = array_instance Array[MType] */ -var71 = 1; -var72 = NEW_array__NativeArray(var71, &type_array__NativeArraymodel__MType); -((struct instance_array__NativeArray*)var72)->values[0] = (val*) var_elttype; -((void (*)(val*, val*, long))(var70->class->vft[COLOR_array__Array__with_native]))(var70, var72, var71) /* with_native on */; -} -var73 = ((val* (*)(val*, val*))(var69->class->vft[COLOR_model__MClass__get_mtype]))(var69, var70) /* get_mtype on */; -var_vararg = var73; +fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 267); +show_backtrace(1); +} +var60 = var_vararg_rank > var54; +var57 = var60; +goto RET_LABEL58; +RET_LABEL58:(void)0; +} +if (var57){ +var61 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__modelbuilder]))(self) /* modelbuilder on */; +var62 = ((val* (*)(val*))(var61->class->vft[COLOR_modelize_property__ModelBuilder__mpropdef2npropdef]))(var61) /* mpropdef2npropdef on */; +var63 = ((val* (*)(val*, val*))(var62->class->vft[COLOR_abstract_collection__MapRead___91d_93d]))(var62, var_mmethoddef) /* [] on */; +var_node = var63; +var64 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MMethodDef__msignature]))(var_mmethoddef) /* msignature on */; +if (var64 == NULL) { +fprintf(stderr, "Runtime error: %s", "Receiver is null"); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 173); +show_backtrace(1); +} else { +var65 = ((val* (*)(val*))(var64->class->vft[COLOR_model__MSignature__mparameters]))(var64) /* mparameters on */; +} +var66 = ((val* (*)(val*, long))(var65->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var65, var_vararg_rank) /* [] on */; +var67 = ((val* (*)(val*))(var66->class->vft[COLOR_model__MParameter__mtype]))(var66) /* mtype on */; +var_elttype = var67; +var68 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on */; +if (varonce69) { +var70 = varonce69; +} else { +var71 = "Array"; +var72 = 5; +var73 = string__NativeString__to_s_with_length(var71, var72); +var70 = var73; +varonce69 = var70; +} +var74 = ((val* (*)(val*, val*))(var68->class->vft[COLOR_model__MModule__get_primitive_class]))(var68, var70) /* get_primitive_class on */; +var75 = NEW_array__Array(&type_array__Arraymodel__MType); +{ /* var75 = array_instance Array[MType] */ +var76 = 1; +var77 = NEW_array__NativeArray(var76, &type_array__NativeArraymodel__MType); +((struct instance_array__NativeArray*)var77)->values[0] = (val*) var_elttype; +((void (*)(val*, val*, long))(var75->class->vft[COLOR_array__Array__with_native]))(var75, var77, var76) /* with_native on */; +} +var78 = ((val* (*)(val*, val*))(var74->class->vft[COLOR_model__MClass__get_mtype]))(var74, var75) /* get_mtype on */; +var_vararg = var78; ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var_vararg) /* add_type on */; -var74 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on */; -if (varonce75) { -var76 = varonce75; -} else { -var77 = "NativeArray"; -var78 = 11; -var79 = string__NativeString__to_s_with_length(var77, var78); -var76 = var79; -varonce75 = var76; -} -var80 = ((val* (*)(val*, val*))(var74->class->vft[COLOR_model__MModule__get_primitive_class]))(var74, var76) /* get_primitive_class on */; -var81 = NEW_array__Array(&type_array__Arraymodel__MType); -{ /* var81 = array_instance Array[MType] */ -var82 = 1; -var83 = NEW_array__NativeArray(var82, &type_array__NativeArraymodel__MType); -((struct instance_array__NativeArray*)var83)->values[0] = (val*) var_elttype; -((void (*)(val*, val*, long))(var81->class->vft[COLOR_array__Array__with_native]))(var81, var83, var82) /* with_native on */; -} -var84 = ((val* (*)(val*, val*))(var80->class->vft[COLOR_model__MClass__get_mtype]))(var80, var81) /* get_mtype on */; -var_native = var84; +var79 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on */; +if (varonce80) { +var81 = varonce80; +} else { +var82 = "NativeArray"; +var83 = 11; +var84 = string__NativeString__to_s_with_length(var82, var83); +var81 = var84; +varonce80 = var81; +} +var85 = ((val* (*)(val*, val*))(var79->class->vft[COLOR_model__MModule__get_primitive_class]))(var79, var81) /* get_primitive_class on */; +var86 = NEW_array__Array(&type_array__Arraymodel__MType); +{ /* var86 = array_instance Array[MType] */ +var87 = 1; +var88 = NEW_array__NativeArray(var87, &type_array__NativeArraymodel__MType); +((struct instance_array__NativeArray*)var88)->values[0] = (val*) var_elttype; +((void (*)(val*, val*, long))(var86->class->vft[COLOR_array__Array__with_native]))(var86, var88, var87) /* with_native on */; +} +var89 = ((val* (*)(val*, val*))(var85->class->vft[COLOR_model__MClass__get_mtype]))(var85, var86) /* get_mtype on */; +var_native = var89; ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var_native) /* add_type on */; -var85 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__modelbuilder]))(self) /* modelbuilder on */; -if (varonce86) { -var87 = varonce86; -} else { -var88 = "with_native"; -var89 = 11; -var90 = string__NativeString__to_s_with_length(var88, var89); -var87 = var90; -varonce86 = var87; -} -var91 = ((val* (*)(val*))(var_vararg->class->vft[COLOR_model__MClassType__mclass]))(var_vararg) /* mclass on */; -var92 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on */; -var93 = ((val* (*)(val*, val*, val*, val*, val*))(var85->class->vft[COLOR_modelbuilder__ModelBuilder__force_get_primitive_method]))(var85, var_node, var87, var91, var92) /* force_get_primitive_method on */; -((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_monomorphic_send]))(var_v, var_vararg, var93) /* add_monomorphic_send on */; -} else { -} -var94 = NEW_range__Range(&type_range__Rangekernel__Int); -var95 = 0; -var96 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MMethodDef__msignature]))(var_mmethoddef) /* msignature on */; -if (var96 == NULL) { -fprintf(stderr, "Runtime error: %s", "Reciever is null"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 121); -show_backtrace(1); +var90 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__modelbuilder]))(self) /* modelbuilder on */; +if (varonce91) { +var92 = varonce91; } else { -var97 = ((long (*)(val*))(var96->class->vft[COLOR_model__MSignature__arity]))(var96) /* arity on */; +var93 = "with_native"; +var94 = 11; +var95 = string__NativeString__to_s_with_length(var93, var94); +var92 = var95; +varonce91 = var92; } -var98 = BOX_kernel__Int(var95); /* autobox from Int to Discrete */ -var99 = BOX_kernel__Int(var97); /* autobox from Int to Discrete */ -((void (*)(val*, val*, val*))(var94->class->vft[COLOR_range__Range__without_last]))(var94, var98, var99) /* without_last on */; -var100 = ((val* (*)(val*))(var94->class->vft[COLOR_abstract_collection__Collection__iterator]))(var94) /* iterator on */; -for(;;) { -var101 = ((short int (*)(val*))(var100->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var100) /* is_ok on */; -if(!var101) break; -var102 = ((val* (*)(val*))(var100->class->vft[COLOR_abstract_collection__Iterator__item]))(var100) /* item on */; -var103 = ((struct instance_kernel__Int*)var102)->value; /* autounbox from nullable Object to Int */; -var_i = var103; -var104 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MPropDef__mproperty]))(var_mmethoddef) /* mproperty on */; -var105 = ((val* (*)(val*))(var104->class->vft[COLOR_model__MProperty__intro]))(var104) /* intro on */; -var106 = ((val* (*)(val*))(var105->class->vft[COLOR_model__MMethodDef__msignature]))(var105) /* msignature on */; -if (var106 == NULL) { -fprintf(stderr, "Runtime error: %s", "Reciever is null"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 122); +var96 = ((val* (*)(val*))(var_vararg->class->vft[COLOR_model__MClassType__mclass]))(var_vararg) /* mclass on */; +var97 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on */; +var98 = ((val* (*)(val*, val*, val*, val*, val*))(var90->class->vft[COLOR_modelbuilder__ModelBuilder__force_get_primitive_method]))(var90, var_node, var92, var96, var97) /* force_get_primitive_method on */; +((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_monomorphic_send]))(var_v, var_vararg, var98) /* add_monomorphic_send on */; +} else { +} +var99 = NEW_range__Range(&type_range__Rangekernel__Int); +var100 = 0; +var101 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MMethodDef__msignature]))(var_mmethoddef) /* msignature on */; +if (var101 == NULL) { +fprintf(stderr, "Runtime error: %s", "Receiver is null"); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 183); show_backtrace(1); } else { -var107 = ((val* (*)(val*))(var106->class->vft[COLOR_model__MSignature__mparameters]))(var106) /* mparameters on */; +var102 = ((long (*)(val*))(var101->class->vft[COLOR_model__MSignature__arity]))(var101) /* arity on */; } -var108 = ((val* (*)(val*, long))(var107->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var107, var_i) /* [] on */; -var109 = ((val* (*)(val*))(var108->class->vft[COLOR_model__MParameter__mtype]))(var108) /* mtype on */; -var_origtype = var109; -var110 = ((short int (*)(val*))(var_origtype->class->vft[COLOR_model__MType__need_anchor]))(var_origtype) /* need_anchor on */; -var111 = !var110; -if (var111){ -goto CONTINUE_label112; +var103 = BOX_kernel__Int(var100); /* autobox from Int to Discrete */ +var104 = BOX_kernel__Int(var102); /* autobox from Int to Discrete */ +((void (*)(val*, val*, val*))(var99->class->vft[COLOR_range__Range__without_last]))(var99, var103, var104) /* without_last on */; +var105 = ((val* (*)(val*))(var99->class->vft[COLOR_abstract_collection__Collection__iterator]))(var99) /* iterator on */; +for(;;) { +var106 = ((short int (*)(val*))(var105->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var105) /* is_ok on */; +if(!var106) break; +var107 = ((val* (*)(val*))(var105->class->vft[COLOR_abstract_collection__Iterator__item]))(var105) /* item on */; +var108 = ((struct instance_kernel__Int*)var107)->value; /* autounbox from nullable Object to Int */; +var_i = var108; +var109 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MPropDef__mproperty]))(var_mmethoddef) /* mproperty on */; +var110 = ((val* (*)(val*))(var109->class->vft[COLOR_model__MProperty__intro]))(var109) /* intro on */; +var111 = ((val* (*)(val*))(var110->class->vft[COLOR_model__MMethodDef__msignature]))(var110) /* msignature on */; +if (var111 == NULL) { +fprintf(stderr, "Runtime error: %s", "Receiver is null"); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 184); +show_backtrace(1); +} else { +var112 = ((val* (*)(val*))(var111->class->vft[COLOR_model__MSignature__mparameters]))(var111) /* mparameters on */; +} +var113 = ((val* (*)(val*, long))(var112->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var112, var_i) /* [] on */; +var114 = ((val* (*)(val*))(var113->class->vft[COLOR_model__MParameter__mtype]))(var113) /* mtype on */; +var_origtype = var114; +var115 = ((short int (*)(val*))(var_origtype->class->vft[COLOR_model__MType__need_anchor]))(var_origtype) /* need_anchor on */; +var116 = !var115; +if (var116){ +goto CONTINUE_label; } else { } -var113 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MMethodDef__msignature]))(var_mmethoddef) /* msignature on */; -if (var113 == NULL) { -fprintf(stderr, "Runtime error: %s", "Reciever is null"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 124); +var117 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MMethodDef__msignature]))(var_mmethoddef) /* msignature on */; +if (var117 == NULL) { +fprintf(stderr, "Runtime error: %s", "Receiver is null"); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 186); show_backtrace(1); } else { -var114 = ((val* (*)(val*))(var113->class->vft[COLOR_model__MSignature__mparameters]))(var113) /* mparameters on */; +var118 = ((val* (*)(val*))(var117->class->vft[COLOR_model__MSignature__mparameters]))(var117) /* mparameters on */; } -var115 = ((val* (*)(val*, long))(var114->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var114, var_i) /* [] on */; -var116 = ((val* (*)(val*))(var115->class->vft[COLOR_model__MParameter__mtype]))(var115) /* mtype on */; -var_paramtype = var116; +var119 = ((val* (*)(val*, long))(var118->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var118, var_i) /* [] on */; +var120 = ((val* (*)(val*))(var119->class->vft[COLOR_model__MParameter__mtype]))(var119) /* mtype on */; +var_paramtype = var120; ((void (*)(val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__add_cast]))(self, var_paramtype) /* add_cast on */; -CONTINUE_label112: (void)0; -((void (*)(val*))(var100->class->vft[COLOR_abstract_collection__Iterator__next]))(var100) /* next on */; -} -BREAK_label112: (void)0; -var117 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__modelbuilder]))(self) /* modelbuilder on */; -var118 = ((val* (*)(val*))(var117->class->vft[COLOR_modelize_property__ModelBuilder__mpropdef2npropdef]))(var117) /* mpropdef2npropdef on */; -var119 = ((short int (*)(val*, val*))(var118->class->vft[COLOR_abstract_collection__MapRead__has_key]))(var118, var_mmethoddef) /* has_key on */; -var120 = !var119; -if (var120){ -var121 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MPropDef__mproperty]))(var_mmethoddef) /* mproperty on */; -var122 = ((val* (*)(val*))(var121->class->vft[COLOR_model__MProperty__name]))(var121) /* name on */; -if (varonce123) { -var124 = varonce123; -} else { -var125 = "init"; -var126 = 4; -var127 = string__NativeString__to_s_with_length(var125, var126); -var124 = var127; -varonce123 = var124; -} -var128 = ((short int (*)(val*, val*))(var122->class->vft[COLOR_kernel__Object___61d_61d]))(var122, var124) /* == on */; -if (var128){ -var129 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__modelbuilder]))(self) /* modelbuilder on */; -var130 = ((val* (*)(val*))(var129->class->vft[COLOR_modelize_class__ModelBuilder__mclassdef2nclassdef]))(var129) /* mclassdef2nclassdef on */; -var131 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MPropDef__mclassdef]))(var_mmethoddef) /* mclassdef on */; -var132 = ((val* (*)(val*, val*))(var130->class->vft[COLOR_abstract_collection__MapRead___91d_93d]))(var130, var131) /* [] on */; -var_nclassdef = var132; -var133 = ((val* (*)(val*))(var_nclassdef->class->vft[COLOR_modelize_property__AClassdef__super_inits]))(var_nclassdef) /* super_inits on */; -var_super_inits = var133; -var134 = NULL; +CONTINUE_label: (void)0; +((void (*)(val*))(var105->class->vft[COLOR_abstract_collection__Iterator__next]))(var105) /* next on */; +} +BREAK_label: (void)0; +var121 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__modelbuilder]))(self) /* modelbuilder on */; +var122 = ((val* (*)(val*))(var121->class->vft[COLOR_modelize_property__ModelBuilder__mpropdef2npropdef]))(var121) /* mpropdef2npropdef on */; +var123 = ((short int (*)(val*, val*))(var122->class->vft[COLOR_abstract_collection__MapRead__has_key]))(var122, var_mmethoddef) /* has_key on */; +var124 = !var123; +if (var124){ +var125 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MPropDef__mproperty]))(var_mmethoddef) /* mproperty on */; +var126 = ((val* (*)(val*))(var125->class->vft[COLOR_model__MProperty__name]))(var125) /* name on */; +if (varonce127) { +var128 = varonce127; +} else { +var129 = "init"; +var130 = 4; +var131 = string__NativeString__to_s_with_length(var129, var130); +var128 = var131; +varonce127 = var128; +} +var132 = ((short int (*)(val*, val*))(var126->class->vft[COLOR_kernel__Object___61d_61d]))(var126, var128) /* == on */; +if (var132){ +var133 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__modelbuilder]))(self) /* modelbuilder on */; +var134 = ((val* (*)(val*))(var133->class->vft[COLOR_modelize_class__ModelBuilder__mclassdef2nclassdef]))(var133) /* mclassdef2nclassdef on */; +var135 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MPropDef__mclassdef]))(var_mmethoddef) /* mclassdef on */; +var136 = ((val* (*)(val*, val*))(var134->class->vft[COLOR_abstract_collection__MapRead___91d_93d]))(var134, var135) /* [] on */; +var_nclassdef = var136; +var137 = ((val* (*)(val*))(var_nclassdef->class->vft[COLOR_modelize_property__AClassdef__super_inits]))(var_nclassdef) /* super_inits on */; +var_super_inits = var137; +var138 = NULL; if (var_super_inits == NULL) { -var135 = 0; /* is null */ +var139 = 0; /* is null */ } else { -var135 = 1; /* arg is null and recv is not */ +var139 = 1; /* arg is null and recv is not */ } -if (var135){ -var136 = ((val* (*)(val*))(var_super_inits->class->vft[COLOR_abstract_collection__Collection__iterator]))(var_super_inits) /* iterator on */; +if (var139){ +var140 = ((val* (*)(val*))(var_super_inits->class->vft[COLOR_abstract_collection__Collection__iterator]))(var_super_inits) /* iterator on */; for(;;) { -var137 = ((short int (*)(val*))(var136->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var136) /* is_ok on */; -if(!var137) break; -var138 = ((val* (*)(val*))(var136->class->vft[COLOR_abstract_collection__Iterator__item]))(var136) /* item on */; -var_su = var138; -var139 = ((val* (*)(val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__receiver]))(var_v) /* receiver on */; -((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_monomorphic_send]))(var_v, var139, var_su) /* add_monomorphic_send on */; -CONTINUE_label140: (void)0; -((void (*)(val*))(var136->class->vft[COLOR_abstract_collection__Iterator__next]))(var136) /* next on */; +var141 = ((short int (*)(val*))(var140->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var140) /* is_ok on */; +if(!var141) break; +var142 = ((val* (*)(val*))(var140->class->vft[COLOR_abstract_collection__Iterator__item]))(var140) /* item on */; +var_su = var142; +var143 = ((val* (*)(val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__receiver]))(var_v) /* receiver on */; +((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_monomorphic_send]))(var_v, var143, var_su) /* add_monomorphic_send on */; +CONTINUE_label144: (void)0; +((void (*)(val*))(var140->class->vft[COLOR_abstract_collection__Iterator__next]))(var140) /* next on */; } -BREAK_label140: (void)0; +BREAK_label144: (void)0; } else { } } else { fprintf(stderr, "Runtime error: %s", "Aborted"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 142); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 204); show_backtrace(1); } -goto CONTINUE_label141; +goto CONTINUE_label145; } else { } -var142 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__modelbuilder]))(self) /* modelbuilder on */; -var143 = ((val* (*)(val*))(var142->class->vft[COLOR_modelize_property__ModelBuilder__mpropdef2npropdef]))(var142) /* mpropdef2npropdef on */; -var144 = ((val* (*)(val*, val*))(var143->class->vft[COLOR_abstract_collection__MapRead___91d_93d]))(var143, var_mmethoddef) /* [] on */; -var_npropdef = var144; +var146 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__modelbuilder]))(self) /* modelbuilder on */; +var147 = ((val* (*)(val*))(var146->class->vft[COLOR_modelize_property__ModelBuilder__mpropdef2npropdef]))(var146) /* mpropdef2npropdef on */; +var148 = ((val* (*)(val*, val*))(var147->class->vft[COLOR_abstract_collection__MapRead___91d_93d]))(var147, var_mmethoddef) /* [] on */; +var_npropdef = var148; /* isa AConcreteMethPropdef */ -cltype146 = type_parser_nodes__AConcreteMethPropdef.color; -idtype147 = type_parser_nodes__AConcreteMethPropdef.id; -if(cltype146 >= var_npropdef->type->table_size) { -var145 = 0; +cltype150 = type_parser_nodes__AConcreteMethPropdef.color; +idtype151 = type_parser_nodes__AConcreteMethPropdef.id; +if(cltype150 >= var_npropdef->type->table_size) { +var149 = 0; } else { -var145 = var_npropdef->type->type_table[cltype146] == idtype147; +var149 = var_npropdef->type->type_table[cltype150] == idtype151; } -if (var145){ -var148 = ((val* (*)(val*))(var_npropdef->class->vft[COLOR_auto_super_init__AConcreteMethPropdef__auto_super_inits]))(var_npropdef) /* auto_super_inits on */; -var_auto_super_inits = var148; -var149 = NULL; +if (var149){ +var152 = ((val* (*)(val*))(var_npropdef->class->vft[COLOR_auto_super_init__AConcreteMethPropdef__auto_super_inits]))(var_npropdef) /* auto_super_inits on */; +var_auto_super_inits = var152; +var153 = NULL; if (var_auto_super_inits == NULL) { -var150 = 0; /* is null */ +var154 = 0; /* is null */ } else { -var150 = 1; /* arg is null and recv is not */ +var154 = 1; /* arg is null and recv is not */ } -if (var150){ -var151 = ((val* (*)(val*))(var_auto_super_inits->class->vft[COLOR_abstract_collection__Collection__iterator]))(var_auto_super_inits) /* iterator on */; +if (var154){ +var155 = ((val* (*)(val*))(var_auto_super_inits->class->vft[COLOR_abstract_collection__Collection__iterator]))(var_auto_super_inits) /* iterator on */; for(;;) { -var152 = ((short int (*)(val*))(var151->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var151) /* is_ok on */; -if(!var152) break; -var153 = ((val* (*)(val*))(var151->class->vft[COLOR_abstract_collection__Iterator__item]))(var151) /* item on */; -var_auto_super_init = var153; -var154 = ((val* (*)(val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__receiver]))(var_v) /* receiver on */; -((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_monomorphic_send]))(var_v, var154, var_auto_super_init) /* add_monomorphic_send on */; -CONTINUE_label155: (void)0; -((void (*)(val*))(var151->class->vft[COLOR_abstract_collection__Iterator__next]))(var151) /* next on */; +var156 = ((short int (*)(val*))(var155->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var155) /* is_ok on */; +if(!var156) break; +var157 = ((val* (*)(val*))(var155->class->vft[COLOR_abstract_collection__Iterator__item]))(var155) /* item on */; +var_auto_super_init = var157; +((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_callsite]))(var_v, var_auto_super_init) /* add_callsite on */; +CONTINUE_label158: (void)0; +((void (*)(val*))(var155->class->vft[COLOR_abstract_collection__Iterator__next]))(var155) /* next on */; } -BREAK_label155: (void)0; +BREAK_label158: (void)0; } else { } } else { /* isa AInternMethPropdef */ -cltype158 = type_parser_nodes__AInternMethPropdef.color; -idtype159 = type_parser_nodes__AInternMethPropdef.id; -if(cltype158 >= var_npropdef->type->table_size) { -var157 = 0; +cltype161 = type_parser_nodes__AInternMethPropdef.color; +idtype162 = type_parser_nodes__AInternMethPropdef.id; +if(cltype161 >= var_npropdef->type->table_size) { +var160 = 0; } else { -var157 = var_npropdef->type->type_table[cltype158] == idtype159; +var160 = var_npropdef->type->type_table[cltype161] == idtype162; } -var_ = var157; -if (var157){ -var156 = var_; +var_ = var160; +if (var160){ +var159 = var_; } else { /* isa AExternMethPropdef */ -cltype162 = type_parser_nodes__AExternMethPropdef.color; -idtype163 = type_parser_nodes__AExternMethPropdef.id; -if(cltype162 >= var_npropdef->type->table_size) { -var161 = 0; +cltype165 = type_parser_nodes__AExternMethPropdef.color; +idtype166 = type_parser_nodes__AExternMethPropdef.id; +if(cltype165 >= var_npropdef->type->table_size) { +var164 = 0; } else { -var161 = var_npropdef->type->type_table[cltype162] == idtype163; +var164 = var_npropdef->type->type_table[cltype165] == idtype166; } -var_164 = var161; -if (var161){ -var165 = ((val* (*)(val*))(var_npropdef->class->vft[COLOR_parser_nodes__AExternPropdef__n_extern]))(var_npropdef) /* n_extern on */; -var166 = NULL; -if (var165 == NULL) { -var167 = 0; /* is null */ +var_167 = var164; +if (var164){ +var168 = ((val* (*)(val*))(var_npropdef->class->vft[COLOR_parser_nodes__AExternPropdef__n_extern]))(var_npropdef) /* n_extern on */; +var169 = NULL; +if (var168 == NULL) { +var170 = 0; /* is null */ } else { -var167 = 1; /* arg is null and recv is not */ +var170 = 1; /* arg is null and recv is not */ } -var160 = var167; +var163 = var170; } else { -var160 = var_164; +var163 = var_167; } -var156 = var160; +var159 = var163; } -if (var156){ -var168 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MMethodDef__msignature]))(var_mmethoddef) /* msignature on */; -if (var168 == NULL) { -fprintf(stderr, "Runtime error: %s", "Reciever is null"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 159); +if (var159){ +var171 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MMethodDef__msignature]))(var_mmethoddef) /* msignature on */; +if (var171 == NULL) { +fprintf(stderr, "Runtime error: %s", "Receiver is null"); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 221); show_backtrace(1); } else { -var169 = ((val* (*)(val*))(var168->class->vft[COLOR_model__MSignature__return_mtype]))(var168) /* return_mtype on */; +var172 = ((val* (*)(val*))(var171->class->vft[COLOR_model__MSignature__return_mtype]))(var171) /* return_mtype on */; } -var_ret = var169; -var173 = NULL; +var_ret = var172; +var176 = NULL; if (var_ret == NULL) { -var174 = 0; /* is null */ +var177 = 0; /* is null */ } else { -var174 = 1; /* arg is null and recv is not */ +var177 = 1; /* arg is null and recv is not */ } -var_175 = var174; -if (var174){ +var_178 = var177; +if (var177){ /* isa MClassType */ -cltype177 = type_model__MClassType.color; -idtype178 = type_model__MClassType.id; -if(cltype177 >= var_ret->type->table_size) { -var176 = 0; +cltype180 = type_model__MClassType.color; +idtype181 = type_model__MClassType.id; +if(cltype180 >= var_ret->type->table_size) { +var179 = 0; } else { -var176 = var_ret->type->type_table[cltype177] == idtype178; +var179 = var_ret->type->type_table[cltype180] == idtype181; } -var172 = var176; +var175 = var179; } else { -var172 = var_175; +var175 = var_178; } -var_179 = var172; -if (var172){ -var180 = ((val* (*)(val*))(var_ret->class->vft[COLOR_model__MClassType__mclass]))(var_ret) /* mclass on */; -var181 = ((val* (*)(val*))(var180->class->vft[COLOR_model__MClass__kind]))(var180) /* kind on */; -var182 = ((val* (*)(val*))(self->class->vft[COLOR_model__Object__abstract_kind]))(self) /* abstract_kind on */; -var183 = ((short int (*)(val*, val*))(var181->class->vft[COLOR_kernel__Object___33d_61d]))(var181, var182) /* != on */; -var171 = var183; +var_182 = var175; +if (var175){ +var183 = ((val* (*)(val*))(var_ret->class->vft[COLOR_model__MClassType__mclass]))(var_ret) /* mclass on */; +var184 = ((val* (*)(val*))(var183->class->vft[COLOR_model__MClass__kind]))(var183) /* kind on */; +var185 = ((val* (*)(val*))(self->class->vft[COLOR_model__Object__abstract_kind]))(self) /* abstract_kind on */; +var186 = ((short int (*)(val*, val*))(var184->class->vft[COLOR_kernel__Object___33d_61d]))(var184, var185) /* != on */; +var174 = var186; } else { -var171 = var_179; +var174 = var_182; } -var_184 = var171; -if (var171){ -var185 = ((val* (*)(val*))(var_ret->class->vft[COLOR_model__MClassType__mclass]))(var_ret) /* mclass on */; -var186 = ((val* (*)(val*))(var185->class->vft[COLOR_model__MClass__kind]))(var185) /* kind on */; -var187 = ((val* (*)(val*))(self->class->vft[COLOR_model__Object__interface_kind]))(self) /* interface_kind on */; -var188 = ((short int (*)(val*, val*))(var186->class->vft[COLOR_kernel__Object___33d_61d]))(var186, var187) /* != on */; -var170 = var188; +var_187 = var174; +if (var174){ +var188 = ((val* (*)(val*))(var_ret->class->vft[COLOR_model__MClassType__mclass]))(var_ret) /* mclass on */; +var189 = ((val* (*)(val*))(var188->class->vft[COLOR_model__MClass__kind]))(var188) /* kind on */; +var190 = ((val* (*)(val*))(self->class->vft[COLOR_model__Object__interface_kind]))(self) /* interface_kind on */; +var191 = ((short int (*)(val*, val*))(var189->class->vft[COLOR_kernel__Object___33d_61d]))(var189, var190) /* != on */; +var173 = var191; } else { -var170 = var_184; +var173 = var_187; } -if (var170){ +if (var173){ ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var_ret) /* add_type on */; } else { } } else { /* isa AExternMethPropdef */ -cltype190 = type_parser_nodes__AExternMethPropdef.color; -idtype191 = type_parser_nodes__AExternMethPropdef.id; -if(cltype190 >= var_npropdef->type->table_size) { -var189 = 0; +cltype193 = type_parser_nodes__AExternMethPropdef.color; +idtype194 = type_parser_nodes__AExternMethPropdef.id; +if(cltype193 >= var_npropdef->type->table_size) { +var192 = 0; } else { -var189 = var_npropdef->type->type_table[cltype190] == idtype191; +var192 = var_npropdef->type->type_table[cltype193] == idtype194; } -if (var189){ -var192 = ((val* (*)(val*))(var_npropdef->class->vft[COLOR_parser_nodes__ANode__parent]))(var_npropdef) /* parent on */; -/* isa AClassdef */ -cltype194 = type_parser_nodes__AClassdef.color; -idtype195 = type_parser_nodes__AClassdef.id; -if(var192 == NULL) { -var193 = 0; +if (var192){ +var195 = ((val* (*)(val*))(var_npropdef->class->vft[COLOR_parser_nodes__ANode__parent]))(var_npropdef) /* parent on */; +/* isa AClassdef */ +cltype197 = type_parser_nodes__AClassdef.color; +idtype198 = type_parser_nodes__AClassdef.id; +if(var195 == NULL) { +var196 = 0; } else { -if(cltype194 >= var192->type->table_size) { -var193 = 0; +if(cltype197 >= var195->type->table_size) { +var196 = 0; } else { -var193 = var192->type->type_table[cltype194] == idtype195; +var196 = var195->type->type_table[cltype197] == idtype198; } } -if (!var193) { -var_class_name196 = var192 == NULL ? "null" : var192->type->name; -fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "AClassdef", var_class_name196); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 164); +if (!var196) { +var_class_name199 = var195 == NULL ? "null" : var195->type->name; +fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "AClassdef", var_class_name199); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 226); show_backtrace(1); } -var_nclassdef197 = var192; +var_nclassdef200 = var195; ((void (*)(val*, val*))(var_v->class->vft[COLOR_parser_nodes__Visitor__enter_visit]))(var_v, var_npropdef) /* enter_visit on */; } else { /* isa AExternInitPropdef */ -cltype199 = type_parser_nodes__AExternInitPropdef.color; -idtype200 = type_parser_nodes__AExternInitPropdef.id; -if(cltype199 >= var_npropdef->type->table_size) { -var198 = 0; +cltype202 = type_parser_nodes__AExternInitPropdef.color; +idtype203 = type_parser_nodes__AExternInitPropdef.id; +if(cltype202 >= var_npropdef->type->table_size) { +var201 = 0; } else { -var198 = var_npropdef->type->type_table[cltype199] == idtype200; +var201 = var_npropdef->type->type_table[cltype202] == idtype203; } -if (var198){ -var201 = ((val* (*)(val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__receiver]))(var_v) /* receiver on */; -((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var201) /* add_type on */; +if (var201){ +var204 = ((val* (*)(val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__receiver]))(var_v) /* receiver on */; +((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var204) /* add_type on */; } else { } } } } ((void (*)(val*, val*))(var_v->class->vft[COLOR_parser_nodes__Visitor__enter_visit]))(var_v, var_npropdef) /* enter_visit on */; -CONTINUE_label141: (void)0; -} -BREAK_label141: (void)0; -var202 = NEW_list__List(&type_list__Listmodel__MClassType); -((void (*)(val*))(var202->class->vft[COLOR_list__List__init]))(var202) /* init on */; -var_todo_types = var202; -var203 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_types]))(self) /* live_types on */; -((void (*)(val*, val*))(var_todo_types->class->vft[COLOR_abstract_collection__SimpleCollection__add_all]))(var_todo_types, var203) /* add_all on */; +CONTINUE_label145: (void)0; +} +BREAK_label145: (void)0; +var205 = NEW_list__List(&type_list__Listmodel__MClassType); +((void (*)(val*))(var205->class->vft[COLOR_list__List__init]))(var205) /* init on */; +var_todo_types = var205; +var206 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_types]))(self) /* live_types on */; +((void (*)(val*, val*))(var_todo_types->class->vft[COLOR_abstract_collection__SimpleCollection__add_all]))(var_todo_types, var206) /* add_all on */; for(;;) { -var204 = ((short int (*)(val*))(var_todo_types->class->vft[COLOR_abstract_collection__Collection__is_empty]))(var_todo_types) /* is_empty on */; -var205 = !var204; -if (!var205) break; -var206 = ((val* (*)(val*))(var_todo_types->class->vft[COLOR_abstract_collection__Sequence__shift]))(var_todo_types) /* shift on */; -var_t = var206; -var207 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_open_types]))(self) /* live_open_types on */; -var208 = ((val* (*)(val*))(var207->class->vft[COLOR_abstract_collection__Collection__iterator]))(var207) /* iterator on */; +var207 = ((short int (*)(val*))(var_todo_types->class->vft[COLOR_abstract_collection__Collection__is_empty]))(var_todo_types) /* is_empty on */; +var208 = !var207; +if (!var208) break; +var209 = ((val* (*)(val*))(var_todo_types->class->vft[COLOR_abstract_collection__Sequence__shift]))(var_todo_types) /* shift on */; +var_t = var209; +var210 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_open_types]))(self) /* live_open_types on */; +var211 = ((val* (*)(val*))(var210->class->vft[COLOR_abstract_collection__Collection__iterator]))(var210) /* iterator on */; for(;;) { -var209 = ((short int (*)(val*))(var208->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var208) /* is_ok on */; -if(!var209) break; -var210 = ((val* (*)(val*))(var208->class->vft[COLOR_abstract_collection__Iterator__item]))(var208) /* item on */; -var_ot = var210; -var211 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on */; -var212 = ((short int (*)(val*, val*, val*, val*))(var_ot->class->vft[COLOR_model__MType__can_resolve_for]))(var_ot, var_t, var_t, var211) /* can_resolve_for on */; -var213 = !var212; -if (var213){ -goto CONTINUE_label214; -} else { -} -var215 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on */; -var216 = ((val* (*)(val*, val*, val*))(var_ot->class->vft[COLOR_model__MType__anchor_to]))(var_ot, var215, var_t) /* anchor_to on */; -var_rt = var216; -var217 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_types]))(self) /* live_types on */; -var218 = ((short int (*)(val*, val*))(var217->class->vft[COLOR_abstract_collection__Collection__has]))(var217, var_rt) /* has on */; -if (var218){ -goto CONTINUE_label214; -} else { -} -var219 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_types]))(self) /* live_types on */; -((void (*)(val*, val*))(var219->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var219, var_rt) /* add on */; +var212 = ((short int (*)(val*))(var211->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var211) /* is_ok on */; +if(!var212) break; +var213 = ((val* (*)(val*))(var211->class->vft[COLOR_abstract_collection__Iterator__item]))(var211) /* item on */; +var_ot = var213; +var214 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on */; +var215 = ((short int (*)(val*, val*, val*, val*))(var_ot->class->vft[COLOR_model__MType__can_resolve_for]))(var_ot, var_t, var_t, var214) /* can_resolve_for on */; +var216 = !var215; +if (var216){ +goto CONTINUE_label217; +} else { +} +var218 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on */; +var219 = ((val* (*)(val*, val*, val*))(var_ot->class->vft[COLOR_model__MType__anchor_to]))(var_ot, var218, var_t) /* anchor_to on */; +var_rt = var219; +var220 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_types]))(self) /* live_types on */; +var221 = ((short int (*)(val*, val*))(var220->class->vft[COLOR_abstract_collection__Collection__has]))(var220, var_rt) /* has on */; +if (var221){ +goto CONTINUE_label217; +} else { +} +var222 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_types]))(self) /* live_types on */; +((void (*)(val*, val*))(var222->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var222, var_rt) /* add on */; ((void (*)(val*, val*))(var_todo_types->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_todo_types, var_rt) /* add on */; ((void (*)(val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__check_depth]))(self, var_rt) /* check_depth on */; -CONTINUE_label214: (void)0; -((void (*)(val*))(var208->class->vft[COLOR_abstract_collection__Iterator__next]))(var208) /* next on */; +CONTINUE_label217: (void)0; +((void (*)(val*))(var211->class->vft[COLOR_abstract_collection__Iterator__next]))(var211) /* next on */; } -BREAK_label214: (void)0; -CONTINUE_label220: (void)0; +BREAK_label217: (void)0; +CONTINUE_label223: (void)0; } -BREAK_label220: (void)0; -var221 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_open_cast_types]))(self) /* live_open_cast_types on */; -var222 = ((val* (*)(val*))(var221->class->vft[COLOR_abstract_collection__Collection__iterator]))(var221) /* iterator on */; +BREAK_label223: (void)0; +var224 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_open_cast_types]))(self) /* live_open_cast_types on */; +var225 = ((val* (*)(val*))(var224->class->vft[COLOR_abstract_collection__Collection__iterator]))(var224) /* iterator on */; for(;;) { -var223 = ((short int (*)(val*))(var222->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var222) /* is_ok on */; -if(!var223) break; -var224 = ((val* (*)(val*))(var222->class->vft[COLOR_abstract_collection__Iterator__item]))(var222) /* item on */; -var_ot225 = var224; -var226 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_types]))(self) /* live_types on */; -var227 = ((val* (*)(val*))(var226->class->vft[COLOR_abstract_collection__Collection__iterator]))(var226) /* iterator on */; +var226 = ((short int (*)(val*))(var225->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var225) /* is_ok on */; +if(!var226) break; +var227 = ((val* (*)(val*))(var225->class->vft[COLOR_abstract_collection__Iterator__item]))(var225) /* item on */; +var_ot228 = var227; +var229 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_types]))(self) /* live_types on */; +var230 = ((val* (*)(val*))(var229->class->vft[COLOR_abstract_collection__Collection__iterator]))(var229) /* iterator on */; for(;;) { -var228 = ((short int (*)(val*))(var227->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var227) /* is_ok on */; -if(!var228) break; -var229 = ((val* (*)(val*))(var227->class->vft[COLOR_abstract_collection__Iterator__item]))(var227) /* item on */; -var_t230 = var229; -var231 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on */; -var232 = ((short int (*)(val*, val*, val*, val*))(var_ot225->class->vft[COLOR_model__MType__can_resolve_for]))(var_ot225, var_t230, var_t230, var231) /* can_resolve_for on */; -var233 = !var232; -if (var233){ -goto CONTINUE_label234; -} else { -} -var235 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on */; -var236 = ((val* (*)(val*, val*, val*))(var_ot225->class->vft[COLOR_model__MType__anchor_to]))(var_ot225, var235, var_t230) /* anchor_to on */; -var_rt237 = var236; -/* isa MNullableType */ -cltype239 = type_model__MNullableType.color; -idtype240 = type_model__MNullableType.id; -if(cltype239 >= var_rt237->type->table_size) { -var238 = 0; -} else { -var238 = var_rt237->type->type_table[cltype239] == idtype240; -} -if (var238){ -var241 = ((val* (*)(val*))(var_rt237->class->vft[COLOR_model__MNullableType__mtype]))(var_rt237) /* mtype on */; -var_rt237 = var241; -} else { -} -/* isa MClassType */ -cltype243 = type_model__MClassType.color; -idtype244 = type_model__MClassType.id; -if(cltype243 >= var_rt237->type->table_size) { -var242 = 0; -} else { -var242 = var_rt237->type->type_table[cltype243] == idtype244; -} -if (!var242) { -fprintf(stderr, "Runtime error: %s", "Assert failed"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 203); -show_backtrace(1); +var231 = ((short int (*)(val*))(var230->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var230) /* is_ok on */; +if(!var231) break; +var232 = ((val* (*)(val*))(var230->class->vft[COLOR_abstract_collection__Iterator__item]))(var230) /* item on */; +var_t233 = var232; +var234 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on */; +var235 = ((short int (*)(val*, val*, val*, val*))(var_ot228->class->vft[COLOR_model__MType__can_resolve_for]))(var_ot228, var_t233, var_t233, var234) /* can_resolve_for on */; +var236 = !var235; +if (var236){ +goto CONTINUE_label237; +} else { } -var245 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_cast_types]))(self) /* live_cast_types on */; -((void (*)(val*, val*))(var245->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var245, var_rt237) /* add on */; -CONTINUE_label234: (void)0; -((void (*)(val*))(var227->class->vft[COLOR_abstract_collection__Iterator__next]))(var227) /* next on */; +var238 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on */; +var239 = ((val* (*)(val*, val*, val*))(var_ot228->class->vft[COLOR_model__MType__anchor_to]))(var_ot228, var238, var_t233) /* anchor_to on */; +var_rt240 = var239; +var241 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_cast_types]))(self) /* live_cast_types on */; +((void (*)(val*, val*))(var241->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var241, var_rt240) /* add on */; +CONTINUE_label237: (void)0; +((void (*)(val*))(var230->class->vft[COLOR_abstract_collection__Iterator__next]))(var230) /* next on */; } -BREAK_label234: (void)0; -CONTINUE_label246: (void)0; -((void (*)(val*))(var222->class->vft[COLOR_abstract_collection__Iterator__next]))(var222) /* next on */; +BREAK_label237: (void)0; +CONTINUE_label242: (void)0; +((void (*)(val*))(var225->class->vft[COLOR_abstract_collection__Iterator__next]))(var225) /* next on */; } -BREAK_label246: (void)0; +BREAK_label242: (void)0; RET_LABEL:; } /* method rapid_type_analysis#RapidTypeAnalysis#run_analysis for (self: Object) */ @@ -1348,7 +1788,7 @@ var4 = 1; /* easy isa OTHER*/ if (!var4) { var_class_name = type_kernel__Int.name; fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); -fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 263); +fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 267); show_backtrace(1); } var5 = var_d > var1; @@ -1478,7 +1918,7 @@ var = ((short int (*)(val*))(var_recv->class->vft[COLOR_model__MType__need_ancho var1 = !var; if (!var1) { fprintf(stderr, "Runtime error: %s", "Assert failed"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 221); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 281); show_backtrace(1); } var2 = ((short int (*)(val*))(var_mtype->class->vft[COLOR_model__MType__need_anchor]))(var_mtype) /* need_anchor on */; @@ -1593,7 +2033,7 @@ goto CONTINUE_label44; var48 = ((val* (*)(val*))(var_npropdef->class->vft[COLOR_modelize_property__APropdef__mpropdef]))(var_npropdef) /* mpropdef on */; if (var48 == NULL) { fprintf(stderr, "Runtime error: %s", "Cast failed"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 246); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 306); show_backtrace(1); } var_mpropdef = var48; @@ -1620,49 +2060,16 @@ RET_LABEL:; void rapid_type_analysis__RapidTypeAnalysis__add_cast(val* self, val* p0) { val* var_mtype /* var mtype: MType */; short int var /* : Bool */; -int cltype; -int idtype; -val* var1 /* : MType */; -short int var2 /* : Bool */; -val* var3 /* : HashSet[MType] */; -short int var4 /* : Bool */; -int cltype5; -int idtype6; -val* var7 /* : HashSet[MClassType] */; +val* var1 /* : HashSet[MType] */; +val* var2 /* : HashSet[MType] */; var_mtype = p0; -/* isa MNullableType */ -cltype = type_model__MNullableType.color; -idtype = type_model__MNullableType.id; -if(cltype >= var_mtype->type->table_size) { -var = 0; -} else { -var = var_mtype->type->type_table[cltype] == idtype; -} +var = ((short int (*)(val*))(var_mtype->class->vft[COLOR_model__MType__need_anchor]))(var_mtype) /* need_anchor on */; if (var){ -var1 = ((val* (*)(val*))(var_mtype->class->vft[COLOR_model__MNullableType__mtype]))(var_mtype) /* mtype on */; -var_mtype = var1; -} else { -} -var2 = ((short int (*)(val*))(var_mtype->class->vft[COLOR_model__MType__need_anchor]))(var_mtype) /* need_anchor on */; -if (var2){ -var3 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_open_cast_types]))(self) /* live_open_cast_types on */; -((void (*)(val*, val*))(var3->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var3, var_mtype) /* add on */; +var1 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_open_cast_types]))(self) /* live_open_cast_types on */; +((void (*)(val*, val*))(var1->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var1, var_mtype) /* add on */; } else { -/* isa MClassType */ -cltype5 = type_model__MClassType.color; -idtype6 = type_model__MClassType.id; -if(cltype5 >= var_mtype->type->table_size) { -var4 = 0; -} else { -var4 = var_mtype->type->type_table[cltype5] == idtype6; -} -if (!var4) { -fprintf(stderr, "Runtime error: %s", "Assert failed"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 260); -show_backtrace(1); -} -var7 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_cast_types]))(self) /* live_cast_types on */; -((void (*)(val*, val*))(var7->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var7, var_mtype) /* add on */; +var2 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_cast_types]))(self) /* live_cast_types on */; +((void (*)(val*, val*))(var2->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var2, var_mtype) /* add on */; } RET_LABEL:; } @@ -1760,7 +2167,7 @@ var10 = 1; /* easy isa OTHER*/ if (!var10) { var_class_name = type_kernel__Int.name; fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); -fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 260); +fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 264); show_backtrace(1); } var11 = var6 <= var7; @@ -1978,7 +2385,7 @@ val* var1 /* : RapidTypeAnalysis */; var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeVisitor___64danalysis].val; /* @analysis on */ if (var1 == NULL) { fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @analysis"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 331); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 389); show_backtrace(1); } var = var1; @@ -2011,7 +2418,7 @@ val* var1 /* : MClassType */; var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeVisitor___64dreceiver].val; /* @receiver on */ if (var1 == NULL) { fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @receiver"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 332); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 390); show_backtrace(1); } var = var1; @@ -2044,7 +2451,7 @@ val* var1 /* : MPropDef */; var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeVisitor___64dmpropdef].val; /* @mpropdef on */ if (var1 == NULL) { fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @mpropdef"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 333); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 391); show_backtrace(1); } var = var1; @@ -2088,7 +2495,7 @@ var = ((short int (*)(val*))(var_receiver->class->vft[COLOR_model__MType__need_a var1 = !var; if (!var1) { fprintf(stderr, "Runtime error: %s", "Assert failed"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 340); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 398); show_backtrace(1); } RET_LABEL:; @@ -2221,14 +2628,14 @@ var11 = var_mtype->type->type_table[cltype12] == idtype13; } if (!var11) { fprintf(stderr, "Runtime error: %s", "Assert failed"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 362); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 420); show_backtrace(1); } var14 = ((short int (*)(val*))(var_mtype->class->vft[COLOR_model__MType__need_anchor]))(var_mtype) /* need_anchor on */; var15 = !var14; if (!var15) { fprintf(stderr, "Runtime error: %s", "Assert failed"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 363); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 421); show_backtrace(1); } var = var_mtype; @@ -2298,7 +2705,7 @@ var3 = 1; /* arg is null and recv is not */ } if (!var3) { fprintf(stderr, "Runtime error: %s", "Assert failed"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 375); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 433); show_backtrace(1); } var4 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__analysis]))(self) /* analysis on */; @@ -2306,7 +2713,7 @@ var5 = ((val* (*)(val*))(var4->class->vft[COLOR_rapid_type_analysis__RapidTypeAn var6 = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__Visitor__current_node]))(self) /* current_node on */; if (var6 == NULL) { fprintf(stderr, "Runtime error: %s", "Cast failed"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 376); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 434); show_backtrace(1); } var7 = ((val* (*)(val*))(var_mtype->class->vft[COLOR_model__MClassType__mclass]))(var_mtype) /* mclass on */; @@ -2366,7 +2773,7 @@ var1 = var_mtype->type->type_table[cltype] == idtype; if (!var1) { var_class_name = var_mtype == NULL ? "null" : var_mtype->type->name; fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 381); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 439); show_backtrace(1); } ((void (*)(val*, val*, val*))(var->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__try_send]))(var, var_mtype, var_mproperty) /* try_send on */; @@ -2407,6 +2814,35 @@ void VIRTUAL_rapid_type_analysis__RapidTypeVisitor__add_cast_type(val* self, val rapid_type_analysis__RapidTypeVisitor__add_cast_type(self, p0); RET_LABEL:; } +/* method rapid_type_analysis#RapidTypeVisitor#add_callsite for (self: RapidTypeVisitor, nullable CallSite) */ +void rapid_type_analysis__RapidTypeVisitor__add_callsite(val* self, val* p0) { +val* var_callsite /* var callsite: nullable CallSite */; +val* var /* : null */; +short int var1 /* : Bool */; +val* var2 /* : RapidTypeAnalysis */; +val* var3 /* : MType */; +val* var4 /* : MMethod */; +var_callsite = p0; +var = NULL; +if (var_callsite == NULL) { +var1 = 0; /* is null */ +} else { +var1 = 1; /* arg is null and recv is not */ +} +if (var1){ +var2 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__analysis]))(self) /* analysis on */; +var3 = ((val* (*)(val*))(var_callsite->class->vft[COLOR_typing__CallSite__recv]))(var_callsite) /* recv on */; +var4 = ((val* (*)(val*))(var_callsite->class->vft[COLOR_typing__CallSite__mproperty]))(var_callsite) /* mproperty on */; +((void (*)(val*, val*, val*))(var2->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__add_send]))(var2, var3, var4) /* add_send on */; +} else { +} +RET_LABEL:; +} +/* method rapid_type_analysis#RapidTypeVisitor#add_callsite for (self: Object, nullable CallSite) */ +void VIRTUAL_rapid_type_analysis__RapidTypeVisitor__add_callsite(val* self, val* p0) { +rapid_type_analysis__RapidTypeVisitor__add_callsite(self, p0); +RET_LABEL:; +} /* method rapid_type_analysis#ANode#accept_rapid_type_visitor for (self: ANode, RapidTypeVisitor) */ void rapid_type_analysis__ANode__accept_rapid_type_visitor(val* self, val* p0) { val* var_v /* var v: RapidTypeVisitor */; @@ -2443,7 +2879,7 @@ var1 = var->type->type_table[cltype] == idtype; if (!var1) { var_class_name = var == NULL ? "null" : var->type->name; fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 399); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 459); show_backtrace(1); } ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var) /* add_type on */; @@ -2479,7 +2915,7 @@ var1 = var->type->type_table[cltype] == idtype; if (!var1) { var_class_name = var == NULL ? "null" : var->type->name; fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 406); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 466); show_backtrace(1); } ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var) /* add_type on */; @@ -2515,7 +2951,7 @@ var1 = var->type->type_table[cltype] == idtype; if (!var1) { var_class_name = var == NULL ? "null" : var->type->name; fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 413); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 473); show_backtrace(1); } ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var) /* add_type on */; @@ -2575,7 +3011,7 @@ var1 = var->type->type_table[cltype] == idtype; if (!var1) { var_class_name = var == NULL ? "null" : var->type->name; fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 420); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 480); show_backtrace(1); } var_mtype = var; @@ -2607,7 +3043,7 @@ var_native = var14; var15 = ((val* (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__cleanup_type]))(var_v, var_mtype) /* cleanup_type on */; if (var15 == NULL) { fprintf(stderr, "Runtime error: %s", "Cast failed"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 424); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 484); show_backtrace(1); } var_mtype = var15; @@ -2859,7 +3295,7 @@ var1 = var->type->type_table[cltype] == idtype; if (!var1) { var_class_name = var == NULL ? "null" : var->type->name; fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 456); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 516); show_backtrace(1); } var_mtype = var; @@ -2916,7 +3352,7 @@ var1 = var->type->type_table[cltype] == idtype; if (!var1) { var_class_name = var == NULL ? "null" : var->type->name; fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 466); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 526); show_backtrace(1); } var_mtype = var; @@ -2965,7 +3401,7 @@ var1 = var->type->type_table[cltype] == idtype; if (!var1) { var_class_name = var == NULL ? "null" : var->type->name; fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 476); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 536); show_backtrace(1); } ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var) /* add_type on */; @@ -3001,7 +3437,7 @@ var1 = var->type->type_table[cltype] == idtype; if (!var1) { var_class_name = var == NULL ? "null" : var->type->name; fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 483); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 543); show_backtrace(1); } ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var) /* add_type on */; @@ -3020,7 +3456,7 @@ var_v = p0; var = ((val* (*)(val*))(self->class->vft[COLOR_typing__AIsaExpr__cast_type]))(self) /* cast_type on */; if (var == NULL) { fprintf(stderr, "Runtime error: %s", "Cast failed"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 490); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 550); show_backtrace(1); } ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_cast_type]))(var_v, var) /* add_cast_type on */; @@ -3039,7 +3475,7 @@ var_v = p0; var = ((val* (*)(val*))(self->class->vft[COLOR_typing__AExpr__mtype]))(self) /* mtype on */; if (var == NULL) { fprintf(stderr, "Runtime error: %s", "Cast failed"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 497); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 557); show_backtrace(1); } ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_cast_type]))(var_v, var) /* add_cast_type on */; @@ -3053,28 +3489,10 @@ RET_LABEL:; /* method rapid_type_analysis#ASendExpr#accept_rapid_type_visitor for (self: ASendExpr, RapidTypeVisitor) */ void rapid_type_analysis__ASendExpr__accept_rapid_type_visitor(val* self, val* p0) { val* var_v /* var v: RapidTypeVisitor */; -val* var /* : nullable MMethod */; -val* var_mproperty /* var mproperty: MMethod */; -val* var1 /* : AExpr */; -val* var2 /* : nullable MType */; -val* var_recvtype /* var recvtype: MType */; +val* var /* : nullable CallSite */; var_v = p0; -var = ((val* (*)(val*))(self->class->vft[COLOR_typing__ASendExpr__mproperty]))(self) /* mproperty on */; -if (var == NULL) { -fprintf(stderr, "Runtime error: %s", "Cast failed"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 504); -show_backtrace(1); -} -var_mproperty = var; -var1 = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__ASendExpr__n_expr]))(self) /* n_expr on */; -var2 = ((val* (*)(val*))(var1->class->vft[COLOR_typing__AExpr__mtype]))(var1) /* mtype on */; -if (var2 == NULL) { -fprintf(stderr, "Runtime error: %s", "Cast failed"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 505); -show_backtrace(1); -} -var_recvtype = var2; -((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_send]))(var_v, var_recvtype, var_mproperty) /* add_send on */; +var = ((val* (*)(val*))(self->class->vft[COLOR_typing__ASendExpr__callsite]))(self) /* callsite on */; +((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_callsite]))(var_v, var) /* add_callsite on */; RET_LABEL:; } /* method rapid_type_analysis#ASendExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */ @@ -3085,78 +3503,16 @@ RET_LABEL:; /* method rapid_type_analysis#ASendReassignFormExpr#accept_rapid_type_visitor for (self: ASendReassignFormExpr, RapidTypeVisitor) */ void rapid_type_analysis__ASendReassignFormExpr__accept_rapid_type_visitor(val* self, val* p0) { val* var_v /* var v: RapidTypeVisitor */; -val* var /* : nullable MType */; -val* var1 /* : nullable MMethodDef */; -val* var2 /* : MProperty */; -val* var3 /* : nullable MMethod */; -val* var_mproperty /* var mproperty: MMethod */; -val* var4 /* : nullable MMethod */; -val* var_write_mproperty /* var write_mproperty: MMethod */; -val* var5 /* : AExpr */; -short int var6 /* : Bool */; -int cltype; -int idtype; -val* var7 /* : MClassType */; -val* var8 /* : MClassType */; -val* var9 /* : AExpr */; -val* var10 /* : nullable MType */; -val* var_recvtype /* var recvtype: MType */; +val* var /* : nullable CallSite */; +val* var1 /* : nullable CallSite */; +val* var2 /* : nullable CallSite */; var_v = p0; -var = ((val* (*)(val*))(self->class->vft[COLOR_typing__AReassignFormExpr__read_type]))(self) /* read_type on */; -if (var == NULL) { -fprintf(stderr, "Runtime error: %s", "Cast failed"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 514); -show_backtrace(1); -} -var1 = ((val* (*)(val*))(self->class->vft[COLOR_typing__AReassignFormExpr__reassign_property]))(self) /* reassign_property on */; -if (var1 == NULL) { -fprintf(stderr, "Runtime error: %s", "Reciever is null"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 514); -show_backtrace(1); -} else { -var2 = ((val* (*)(val*))(var1->class->vft[COLOR_model__MPropDef__mproperty]))(var1) /* mproperty on */; -} -((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_send]))(var_v, var, var2) /* add_send on */; -var3 = ((val* (*)(val*))(self->class->vft[COLOR_typing__ASendExpr__mproperty]))(self) /* mproperty on */; -if (var3 == NULL) { -fprintf(stderr, "Runtime error: %s", "Cast failed"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 515); -show_backtrace(1); -} -var_mproperty = var3; -var4 = ((val* (*)(val*))(self->class->vft[COLOR_typing__ASendReassignFormExpr__write_mproperty]))(self) /* write_mproperty on */; -if (var4 == NULL) { -fprintf(stderr, "Runtime error: %s", "Cast failed"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 516); -show_backtrace(1); -} -var_write_mproperty = var4; -var5 = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__ASendExpr__n_expr]))(self) /* n_expr on */; -/* isa ASelfExpr */ -cltype = type_parser_nodes__ASelfExpr.color; -idtype = type_parser_nodes__ASelfExpr.id; -if(cltype >= var5->type->table_size) { -var6 = 0; -} else { -var6 = var5->type->type_table[cltype] == idtype; -} -if (var6){ -var7 = ((val* (*)(val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__receiver]))(var_v) /* receiver on */; -((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_monomorphic_send]))(var_v, var7, var_mproperty) /* add_monomorphic_send on */; -var8 = ((val* (*)(val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__receiver]))(var_v) /* receiver on */; -((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_monomorphic_send]))(var_v, var8, var_write_mproperty) /* add_monomorphic_send on */; -} else { -var9 = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__ASendExpr__n_expr]))(self) /* n_expr on */; -var10 = ((val* (*)(val*))(var9->class->vft[COLOR_typing__AExpr__mtype]))(var9) /* mtype on */; -if (var10 == NULL) { -fprintf(stderr, "Runtime error: %s", "Cast failed"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 521); -show_backtrace(1); -} -var_recvtype = var10; -((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_send]))(var_v, var_recvtype, var_mproperty) /* add_send on */; -((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_send]))(var_v, var_recvtype, var_write_mproperty) /* add_send on */; -} +var = ((val* (*)(val*))(self->class->vft[COLOR_typing__ASendExpr__callsite]))(self) /* callsite on */; +((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_callsite]))(var_v, var) /* add_callsite on */; +var1 = ((val* (*)(val*))(self->class->vft[COLOR_typing__AReassignFormExpr__reassign_callsite]))(self) /* reassign_callsite on */; +((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_callsite]))(var_v, var1) /* add_callsite on */; +var2 = ((val* (*)(val*))(self->class->vft[COLOR_typing__ASendReassignFormExpr__write_callsite]))(self) /* write_callsite on */; +((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_callsite]))(var_v, var2) /* add_callsite on */; RET_LABEL:; } /* method rapid_type_analysis#ASendReassignFormExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */ @@ -3167,25 +3523,10 @@ RET_LABEL:; /* method rapid_type_analysis#AVarReassignExpr#accept_rapid_type_visitor for (self: AVarReassignExpr, RapidTypeVisitor) */ void rapid_type_analysis__AVarReassignExpr__accept_rapid_type_visitor(val* self, val* p0) { val* var_v /* var v: RapidTypeVisitor */; -val* var /* : nullable MType */; -val* var1 /* : nullable MMethodDef */; -val* var2 /* : MProperty */; +val* var /* : nullable CallSite */; var_v = p0; -var = ((val* (*)(val*))(self->class->vft[COLOR_typing__AReassignFormExpr__read_type]))(self) /* read_type on */; -if (var == NULL) { -fprintf(stderr, "Runtime error: %s", "Cast failed"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 531); -show_backtrace(1); -} -var1 = ((val* (*)(val*))(self->class->vft[COLOR_typing__AReassignFormExpr__reassign_property]))(self) /* reassign_property on */; -if (var1 == NULL) { -fprintf(stderr, "Runtime error: %s", "Reciever is null"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 531); -show_backtrace(1); -} else { -var2 = ((val* (*)(val*))(var1->class->vft[COLOR_model__MPropDef__mproperty]))(var1) /* mproperty on */; -} -((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_send]))(var_v, var, var2) /* add_send on */; +var = ((val* (*)(val*))(self->class->vft[COLOR_typing__AReassignFormExpr__reassign_callsite]))(self) /* reassign_callsite on */; +((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_callsite]))(var_v, var) /* add_callsite on */; RET_LABEL:; } /* method rapid_type_analysis#AVarReassignExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */ @@ -3196,25 +3537,10 @@ RET_LABEL:; /* method rapid_type_analysis#AAttrReassignExpr#accept_rapid_type_visitor for (self: AAttrReassignExpr, RapidTypeVisitor) */ void rapid_type_analysis__AAttrReassignExpr__accept_rapid_type_visitor(val* self, val* p0) { val* var_v /* var v: RapidTypeVisitor */; -val* var /* : nullable MType */; -val* var1 /* : nullable MMethodDef */; -val* var2 /* : MProperty */; +val* var /* : nullable CallSite */; var_v = p0; -var = ((val* (*)(val*))(self->class->vft[COLOR_typing__AReassignFormExpr__read_type]))(self) /* read_type on */; -if (var == NULL) { -fprintf(stderr, "Runtime error: %s", "Cast failed"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 538); -show_backtrace(1); -} -var1 = ((val* (*)(val*))(self->class->vft[COLOR_typing__AReassignFormExpr__reassign_property]))(self) /* reassign_property on */; -if (var1 == NULL) { -fprintf(stderr, "Runtime error: %s", "Reciever is null"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 538); -show_backtrace(1); -} else { -var2 = ((val* (*)(val*))(var1->class->vft[COLOR_model__MPropDef__mproperty]))(var1) /* mproperty on */; -} -((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_send]))(var_v, var, var2) /* add_send on */; +var = ((val* (*)(val*))(self->class->vft[COLOR_typing__AReassignFormExpr__reassign_callsite]))(self) /* reassign_callsite on */; +((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_callsite]))(var_v, var) /* add_callsite on */; RET_LABEL:; } /* method rapid_type_analysis#AAttrReassignExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */ @@ -3225,51 +3551,36 @@ RET_LABEL:; /* method rapid_type_analysis#ASuperExpr#accept_rapid_type_visitor for (self: ASuperExpr, RapidTypeVisitor) */ void rapid_type_analysis__ASuperExpr__accept_rapid_type_visitor(val* self, val* p0) { val* var_v /* var v: RapidTypeVisitor */; -val* var /* : nullable MMethod */; -val* var_mproperty /* var mproperty: nullable MMethod */; +val* var /* : nullable CallSite */; +val* var_callsite /* var callsite: nullable CallSite */; val* var1 /* : null */; short int var2 /* : Bool */; -val* var3 /* : MClassType */; -val* var4 /* : RapidTypeAnalysis */; -val* var5 /* : MClassType */; -val* var6 /* : MPropDef */; -short int var7 /* : Bool */; -int cltype; -int idtype; -const char* var_class_name; +val* var3 /* : RapidTypeAnalysis */; +val* var4 /* : MClassType */; +val* var5 /* : nullable MMethodDef */; var_v = p0; -var = ((val* (*)(val*))(self->class->vft[COLOR_typing__ASuperExpr__mproperty]))(self) /* mproperty on */; -var_mproperty = var; +var = ((val* (*)(val*))(self->class->vft[COLOR_typing__ASuperExpr__callsite]))(self) /* callsite on */; +var_callsite = var; var1 = NULL; -if (var_mproperty == NULL) { +if (var_callsite == NULL) { var2 = 0; /* is null */ } else { var2 = 1; /* arg is null and recv is not */ } if (var2){ -var3 = ((val* (*)(val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__receiver]))(var_v) /* receiver on */; -((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_monomorphic_send]))(var_v, var3, var_mproperty) /* add_monomorphic_send on */; +((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_callsite]))(var_v, var_callsite) /* add_callsite on */; goto RET_LABEL; } else { } -var4 = ((val* (*)(val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__analysis]))(var_v) /* analysis on */; -var5 = ((val* (*)(val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__receiver]))(var_v) /* receiver on */; -var6 = ((val* (*)(val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__mpropdef]))(var_v) /* mpropdef on */; -/* isa MMethodDef */ -cltype = type_model__MMethodDef.color; -idtype = type_model__MMethodDef.id; -if(cltype >= var6->type->table_size) { -var7 = 0; -} else { -var7 = var6->type->type_table[cltype] == idtype; -} -if (!var7) { -var_class_name = var6 == NULL ? "null" : var6->type->name; -fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MMethodDef", var_class_name); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 551); +var3 = ((val* (*)(val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__analysis]))(var_v) /* analysis on */; +var4 = ((val* (*)(val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__receiver]))(var_v) /* receiver on */; +var5 = ((val* (*)(val*))(self->class->vft[COLOR_typing__ASuperExpr__mpropdef]))(self) /* mpropdef on */; +if (var5 == NULL) { +fprintf(stderr, "Runtime error: %s", "Cast failed"); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 601); show_backtrace(1); } -((void (*)(val*, val*, val*))(var4->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__add_super_send]))(var4, var5, var6) /* add_super_send on */; +((void (*)(val*, val*, val*))(var3->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__add_super_send]))(var3, var4, var5) /* add_super_send on */; RET_LABEL:; } /* method rapid_type_analysis#ASuperExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */ @@ -3356,14 +3667,14 @@ var = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__AForExpr__n_expr])) var1 = ((val* (*)(val*))(var->class->vft[COLOR_typing__AExpr__mtype]))(var) /* mtype on */; if (var1 == NULL) { fprintf(stderr, "Runtime error: %s", "Cast failed"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 558); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 608); show_backtrace(1); } var_recvtype = var1; var2 = ((val* (*)(val*))(self->class->vft[COLOR_typing__AForExpr__coltype]))(self) /* coltype on */; if (var2 == NULL) { fprintf(stderr, "Runtime error: %s", "Cast failed"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 559); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 609); show_backtrace(1); } var_colltype = var2; @@ -3382,8 +3693,8 @@ var_itmeth = var7; var8 = ((val* (*)(val*))(var_itmeth->class->vft[COLOR_model__MProperty__intro]))(var_itmeth) /* intro on */; var9 = ((val* (*)(val*))(var8->class->vft[COLOR_model__MMethodDef__msignature]))(var8) /* msignature on */; if (var9 == NULL) { -fprintf(stderr, "Runtime error: %s", "Reciever is null"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 562); +fprintf(stderr, "Runtime error: %s", "Receiver is null"); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 612); show_backtrace(1); } else { var10 = ((val* (*)(val*))(var9->class->vft[COLOR_model__MSignature__return_mtype]))(var9) /* return_mtype on */; @@ -3403,7 +3714,7 @@ var11 = var10->type->type_table[cltype] == idtype; if (!var11) { var_class_name = var10 == NULL ? "null" : var10->type->name; fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 562); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 612); show_backtrace(1); } var12 = ((val* (*)(val*))(var10->class->vft[COLOR_model__MClassType__mclass]))(var10) /* mclass on */; @@ -3435,8 +3746,8 @@ var27 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysi ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_send]))(var_v, var_objtype, var27) /* add_send on */; var28 = ((val* (*)(val*))(self->class->vft[COLOR_scope__AForExpr__variables]))(self) /* variables on */; if (var28 == NULL) { -fprintf(stderr, "Runtime error: %s", "Reciever is null"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 565); +fprintf(stderr, "Runtime error: %s", "Receiver is null"); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 615); show_backtrace(1); } else { var29 = ((long (*)(val*))(var28->class->vft[COLOR_abstract_collection__Collection__length]))(var28) /* length on */; @@ -3463,8 +3774,8 @@ var39 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysi } else { var40 = ((val* (*)(val*))(self->class->vft[COLOR_scope__AForExpr__variables]))(self) /* variables on */; if (var40 == NULL) { -fprintf(stderr, "Runtime error: %s", "Reciever is null"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 567); +fprintf(stderr, "Runtime error: %s", "Receiver is null"); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 617); show_backtrace(1); } else { var41 = ((long (*)(val*))(var40->class->vft[COLOR_abstract_collection__Collection__length]))(var40) /* length on */; @@ -3501,7 +3812,7 @@ var57 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysi ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_send]))(var_v, var_objtype, var57) /* add_send on */; } else { fprintf(stderr, "Runtime error: %s", "Aborted"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 571); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 621); show_backtrace(1); } } @@ -3532,8 +3843,7 @@ int cltype; int idtype; const char* var_class_name; val* var_mtype /* var mtype: MClassType */; -val* var2 /* : nullable MMethod */; -val* var_mproperty /* var mproperty: MMethod */; +val* var2 /* : nullable CallSite */; var_v = p0; var = ((val* (*)(val*))(self->class->vft[COLOR_typing__AExpr__mtype]))(self) /* mtype on */; /* isa MClassType */ @@ -3551,19 +3861,13 @@ var1 = var->type->type_table[cltype] == idtype; if (!var1) { var_class_name = var == NULL ? "null" : var->type->name; fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 580); +fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 630); show_backtrace(1); } var_mtype = var; ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var_mtype) /* add_type on */; -var2 = ((val* (*)(val*))(self->class->vft[COLOR_typing__ANewExpr__mproperty]))(self) /* mproperty on */; -if (var2 == NULL) { -fprintf(stderr, "Runtime error: %s", "Cast failed"); -fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 582); -show_backtrace(1); -} -var_mproperty = var2; -((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_monomorphic_send]))(var_v, var_mtype, var_mproperty) /* add_monomorphic_send on */; +var2 = ((val* (*)(val*))(self->class->vft[COLOR_typing__ANewExpr__callsite]))(self) /* callsite on */; +((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_callsite]))(var_v, var2) /* add_callsite on */; RET_LABEL:; } /* method rapid_type_analysis#ANewExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */