c_src/nit__rapid_type_analysis.sep.1.c

   1 #include "nit__rapid_type_analysis.sep.0.h"
   2 /* method rapid_type_analysis#ModelBuilder#do_rapid_type_analysis for (self: ModelBuilder, MModule): RapidTypeAnalysis */
   3 val* nit__rapid_type_analysis___ModelBuilder___do_rapid_type_analysis(val* self, val* p0) {
   4 val* var /* : RapidTypeAnalysis */;
   5 val* var_mainmodule /* var mainmodule: MModule */;
   6 val* var1 /* : RapidTypeAnalysis */;
   7 val* var_analysis /* var analysis: RapidTypeAnalysis */;
   8 val* var2 /* : ToolContext */;
   9 val* var4 /* : ToolContext */;
  10 val* var5 /* : OptionBool */;
  11 val* var7 /* : OptionBool */;
  12 val* var8 /* : nullable Object */;
  13 val* var10 /* : nullable Object */;
  14 short int var11 /* : Bool */;
  15 val* var12 /* : ToolContext */;
  16 val* var14 /* : ToolContext */;
  17 val* var15 /* : String */;
  18 val* var17 /* : String */;
  19 val* var18 /* : String */;
  20 val* var20 /* : String */;
  21 val* var21 /* : String */;
  22 val* var_basename /* var basename: String */;
  23 val* var22 /* : OrderedTree[Object] */;
  24 static val* varonce;
  25 val* var23 /* : String */;
  26 char* var24 /* : NativeString */;
  27 val* var25 /* : FlatString */;
  28 val* var26 /* : String */;
  29 val* var27 /* : CsvDocument */;
  30 static val* varonce28;
  31 val* var29 /* : String */;
  32 char* var30 /* : NativeString */;
  33 val* var31 /* : FlatString */;
  34 val* var32 /* : String */;
  35 var_mainmodule = p0;
  36 var1 = NEW_nit__RapidTypeAnalysis(&type_nit__RapidTypeAnalysis);
  37 {
  38 ((void(*)(val* self, val* p0))(var1->class->vft[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis__modelbuilder_61d]))(var1, self); /* modelbuilder= on <var1:RapidTypeAnalysis>*/
  39 }
  40 {
  41 ((void(*)(val* self, val* p0))(var1->class->vft[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis__mainmodule_61d]))(var1, var_mainmodule); /* mainmodule= on <var1:RapidTypeAnalysis>*/
  42 }
  43 {
  44 ((void(*)(val* self))(var1->class->vft[COLOR_standard__kernel__Object__init]))(var1); /* init on <var1:RapidTypeAnalysis>*/
  45 }
  46 var_analysis = var1;
  47 {
  48 nit___nit__RapidTypeAnalysis___run_analysis(var_analysis); /* Direct call rapid_type_analysis#RapidTypeAnalysis#run_analysis on <var_analysis:RapidTypeAnalysis>*/
  49 }
  50 {
  51 { /* Inline modelbuilder_base#ModelBuilder#toolcontext (self) on <self:ModelBuilder> */
  52 var4 = self->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on <self:ModelBuilder> */
  53 if (unlikely(var4 == NULL)) {
  54 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext");
  55 PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47);
  56 fatal_exit(1);
  57 }
  58 var2 = var4;
  59 RET_LABEL3:(void)0;
  60 }
  61 }
  62 {
  63 { /* Inline toolcontext#ToolContext#opt_log (var2) on <var2:ToolContext> */
  64 var7 = var2->attrs[COLOR_nit__toolcontext__ToolContext___opt_log].val; /* _opt_log on <var2:ToolContext> */
  65 if (unlikely(var7 == NULL)) {
  66 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_log");
  67 PRINT_ERROR(" (%s:%d)\n", FILE_nit__toolcontext, 344);
  68 fatal_exit(1);
  69 }
  70 var5 = var7;
  71 RET_LABEL6:(void)0;
  72 }
  73 }
  74 {
  75 { /* Inline opts#Option#value (var5) on <var5:OptionBool> */
  76 var10 = var5->attrs[COLOR_opts__Option___value].val; /* _value on <var5:OptionBool> */
  77 var8 = var10;
  78 RET_LABEL9:(void)0;
  79 }
  80 }
  81 var11 = (short int)((long)(var8)>>2);
  82 if (var11){
  83 {
  84 { /* Inline modelbuilder_base#ModelBuilder#toolcontext (self) on <self:ModelBuilder> */
  85 var14 = self->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on <self:ModelBuilder> */
  86 if (unlikely(var14 == NULL)) {
  87 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext");
  88 PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47);
  89 fatal_exit(1);
  90 }
  91 var12 = var14;
  92 RET_LABEL13:(void)0;
  93 }
  94 }
  95 {
  96 { /* Inline toolcontext#ToolContext#log_directory (var12) on <var12:ToolContext> */
  97 var17 = var12->attrs[COLOR_nit__toolcontext__ToolContext___log_directory].val; /* _log_directory on <var12:ToolContext> */
  98 if (unlikely(var17 == NULL)) {
  99 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _log_directory");
 100 PRINT_ERROR(" (%s:%d)\n", FILE_nit__toolcontext, 137);
 101 fatal_exit(1);
 102 }
 103 var15 = var17;
 104 RET_LABEL16:(void)0;
 105 }
 106 }
 107 {
 108 { /* Inline mmodule#MModule#name (var_mainmodule) on <var_mainmodule:MModule> */
 109 var20 = var_mainmodule->attrs[COLOR_nit__mmodule__MModule___name].val; /* _name on <var_mainmodule:MModule> */
 110 if (unlikely(var20 == NULL)) {
 111 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name");
 112 PRINT_ERROR(" (%s:%d)\n", FILE_nit__mmodule, 87);
 113 fatal_exit(1);
 114 }
 115 var18 = var20;
 116 RET_LABEL19:(void)0;
 117 }
 118 }
 119 {
 120 var21 = standard__file___String____47d(var15, var18);
 121 }
 122 var_basename = var21;
 123 {
 124 var22 = nit___nit__RapidTypeAnalysis___live_methods_to_tree(var_analysis);
 125 }
 126 if (likely(varonce!=NULL)) {
 127 var23 = varonce;
 128 } else {
 129 var24 = ".rta_methods.txt";
 130 var25 = standard___standard__NativeString___to_s_with_length(var24, 16l);
 131 var23 = var25;
 132 varonce = var23;
 133 }
 134 {
 135 var26 = ((val*(*)(val* self, val* p0))(var_basename->class->vft[COLOR_standard__string__String___43d]))(var_basename, var23); /* + on <var_basename:String>*/
 136 }
 137 {
 138 standard__file___Writable___write_to_file(var22, var26); /* Direct call file#Writable#write_to_file on <var22:OrderedTree[Object]>*/
 139 }
 140 {
 141 var27 = nit___nit__RapidTypeAnalysis___live_types_to_csv(var_analysis);
 142 }
 143 if (likely(varonce28!=NULL)) {
 144 var29 = varonce28;
 145 } else {
 146 var30 = ".rta_types.csv";
 147 var31 = standard___standard__NativeString___to_s_with_length(var30, 14l);
 148 var29 = var31;
 149 varonce28 = var29;
 150 }
 151 {
 152 var32 = ((val*(*)(val* self, val* p0))(var_basename->class->vft[COLOR_standard__string__String___43d]))(var_basename, var29); /* + on <var_basename:String>*/
 153 }
 154 {
 155 standard__file___Writable___write_to_file(var27, var32); /* Direct call file#Writable#write_to_file on <var27:CsvDocument>*/
 156 }
 157 } else {
 158 }
 159 var = var_analysis;
 160 goto RET_LABEL;
 161 RET_LABEL:;
 162 return var;
 163 }
 164 /* method rapid_type_analysis#RapidTypeAnalysis#modelbuilder for (self: RapidTypeAnalysis): ModelBuilder */
 165 val* nit___nit__RapidTypeAnalysis___modelbuilder(val* self) {
 166 val* var /* : ModelBuilder */;
 167 val* var1 /* : ModelBuilder */;
 168 var1 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___modelbuilder].val; /* _modelbuilder on <self:RapidTypeAnalysis> */
 169 if (unlikely(var1 == NULL)) {
 170 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder");
 171 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 53);
 172 fatal_exit(1);
 173 }
 174 var = var1;
 175 RET_LABEL:;
 176 return var;
 177 }
 178 /* method rapid_type_analysis#RapidTypeAnalysis#modelbuilder= for (self: RapidTypeAnalysis, ModelBuilder) */
 179 void nit___nit__RapidTypeAnalysis___modelbuilder_61d(val* self, val* p0) {
 180 self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___modelbuilder].val = p0; /* _modelbuilder on <self:RapidTypeAnalysis> */
 181 RET_LABEL:;
 182 }
 183 /* method rapid_type_analysis#RapidTypeAnalysis#mainmodule for (self: RapidTypeAnalysis): MModule */
 184 val* nit___nit__RapidTypeAnalysis___mainmodule(val* self) {
 185 val* var /* : MModule */;
 186 val* var1 /* : MModule */;
 187 var1 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
 188 if (unlikely(var1 == NULL)) {
 189 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
 190 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
 191 fatal_exit(1);
 192 }
 193 var = var1;
 194 RET_LABEL:;
 195 return var;
 196 }
 197 /* method rapid_type_analysis#RapidTypeAnalysis#mainmodule= for (self: RapidTypeAnalysis, MModule) */
 198 void nit___nit__RapidTypeAnalysis___mainmodule_61d(val* self, val* p0) {
 199 self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val = p0; /* _mainmodule on <self:RapidTypeAnalysis> */
 200 RET_LABEL:;
 201 }
 202 /* method rapid_type_analysis#RapidTypeAnalysis#live_types for (self: RapidTypeAnalysis): HashSet[MClassType] */
 203 val* nit___nit__RapidTypeAnalysis___live_types(val* self) {
 204 val* var /* : HashSet[MClassType] */;
 205 val* var1 /* : HashSet[MClassType] */;
 206 var1 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on <self:RapidTypeAnalysis> */
 207 if (unlikely(var1 == NULL)) {
 208 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types");
 209 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 60);
 210 fatal_exit(1);
 211 }
 212 var = var1;
 213 RET_LABEL:;
 214 return var;
 215 }
 216 /* method rapid_type_analysis#RapidTypeAnalysis#live_open_types for (self: RapidTypeAnalysis): HashSet[MClassType] */
 217 val* nit___nit__RapidTypeAnalysis___live_open_types(val* self) {
 218 val* var /* : HashSet[MClassType] */;
 219 val* var1 /* : HashSet[MClassType] */;
 220 var1 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_open_types].val; /* _live_open_types on <self:RapidTypeAnalysis> */
 221 if (unlikely(var1 == NULL)) {
 222 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_open_types");
 223 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 65);
 224 fatal_exit(1);
 225 }
 226 var = var1;
 227 RET_LABEL:;
 228 return var;
 229 }
 230 /* method rapid_type_analysis#RapidTypeAnalysis#live_classes for (self: RapidTypeAnalysis): HashSet[MClass] */
 231 val* nit___nit__RapidTypeAnalysis___live_classes(val* self) {
 232 val* var /* : HashSet[MClass] */;
 233 val* var1 /* : HashSet[MClass] */;
 234 var1 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_classes].val; /* _live_classes on <self:RapidTypeAnalysis> */
 235 if (unlikely(var1 == NULL)) {
 236 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_classes");
 237 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 69);
 238 fatal_exit(1);
 239 }
 240 var = var1;
 241 RET_LABEL:;
 242 return var;
 243 }
 244 /* method rapid_type_analysis#RapidTypeAnalysis#live_cast_types for (self: RapidTypeAnalysis): HashSet[MType] */
 245 val* nit___nit__RapidTypeAnalysis___live_cast_types(val* self) {
 246 val* var /* : HashSet[MType] */;
 247 val* var1 /* : HashSet[MType] */;
 248 var1 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_cast_types].val; /* _live_cast_types on <self:RapidTypeAnalysis> */
 249 if (unlikely(var1 == NULL)) {
 250 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_cast_types");
 251 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 72);
 252 fatal_exit(1);
 253 }
 254 var = var1;
 255 RET_LABEL:;
 256 return var;
 257 }
 258 /* method rapid_type_analysis#RapidTypeAnalysis#live_open_cast_types for (self: RapidTypeAnalysis): HashSet[MType] */
 259 val* nit___nit__RapidTypeAnalysis___live_open_cast_types(val* self) {
 260 val* var /* : HashSet[MType] */;
 261 val* var1 /* : HashSet[MType] */;
 262 var1 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_open_cast_types].val; /* _live_open_cast_types on <self:RapidTypeAnalysis> */
 263 if (unlikely(var1 == NULL)) {
 264 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_open_cast_types");
 265 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 75);
 266 fatal_exit(1);
 267 }
 268 var = var1;
 269 RET_LABEL:;
 270 return var;
 271 }
 272 /* method rapid_type_analysis#RapidTypeAnalysis#live_methoddefs for (self: RapidTypeAnalysis): HashSet[MMethodDef] */
 273 val* nit___nit__RapidTypeAnalysis___live_methoddefs(val* self) {
 274 val* var /* : HashSet[MMethodDef] */;
 275 val* var1 /* : HashSet[MMethodDef] */;
 276 var1 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_methoddefs].val; /* _live_methoddefs on <self:RapidTypeAnalysis> */
 277 if (unlikely(var1 == NULL)) {
 278 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_methoddefs");
 279 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 79);
 280 fatal_exit(1);
 281 }
 282 var = var1;
 283 RET_LABEL:;
 284 return var;
 285 }
 286 /* method rapid_type_analysis#RapidTypeAnalysis#live_methods for (self: RapidTypeAnalysis): HashSet[MMethod] */
 287 val* nit___nit__RapidTypeAnalysis___live_methods(val* self) {
 288 val* var /* : HashSet[MMethod] */;
 289 val* var1 /* : HashSet[MMethod] */;
 290 var1 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_methods].val; /* _live_methods on <self:RapidTypeAnalysis> */
 291 if (unlikely(var1 == NULL)) {
 292 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_methods");
 293 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 82);
 294 fatal_exit(1);
 295 }
 296 var = var1;
 297 RET_LABEL:;
 298 return var;
 299 }
 300 /* method rapid_type_analysis#RapidTypeAnalysis#live_callsites for (self: RapidTypeAnalysis): HashSet[CallSite] */
 301 val* nit___nit__RapidTypeAnalysis___live_callsites(val* self) {
 302 val* var /* : HashSet[CallSite] */;
 303 val* var1 /* : HashSet[CallSite] */;
 304 var1 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_callsites].val; /* _live_callsites on <self:RapidTypeAnalysis> */
 305 if (unlikely(var1 == NULL)) {
 306 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_callsites");
 307 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 85);
 308 fatal_exit(1);
 309 }
 310 var = var1;
 311 RET_LABEL:;
 312 return var;
 313 }
 314 /* method rapid_type_analysis#RapidTypeAnalysis#live_targets_cache for (self: RapidTypeAnalysis): HashMap2[MType, MProperty, Set[MMethodDef]] */
 315 val* nit___nit__RapidTypeAnalysis___live_targets_cache(val* self) {
 316 val* var /* : HashMap2[MType, MProperty, Set[MMethodDef]] */;
 317 val* var1 /* : HashMap2[MType, MProperty, Set[MMethodDef]] */;
 318 var1 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_targets_cache].val; /* _live_targets_cache on <self:RapidTypeAnalysis> */
 319 if (unlikely(var1 == NULL)) {
 320 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_targets_cache");
 321 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 88);
 322 fatal_exit(1);
 323 }
 324 var = var1;
 325 RET_LABEL:;
 326 return var;
 327 }
 328 /* method rapid_type_analysis#RapidTypeAnalysis#live_targets for (self: RapidTypeAnalysis, CallSite): Set[MMethodDef] */
 329 val* nit___nit__RapidTypeAnalysis___live_targets(val* self, val* p0) {
 330 val* var /* : Set[MMethodDef] */;
 331 val* var_callsite /* var callsite: CallSite */;
 332 val* var1 /* : MType */;
 333 val* var3 /* : MType */;
 334 val* var_mtype /* var mtype: MType */;
 335 val* var4 /* : nullable MClassType */;
 336 val* var6 /* : nullable MClassType */;
 337 val* var_anchor /* var anchor: nullable MClassType */;
 338 short int var7 /* : Bool */;
 339 short int var8 /* : Bool */;
 340 val* var_other /* var other: nullable Object */;
 341 short int var10 /* : Bool */;
 342 short int var11 /* : Bool */;
 343 val* var12 /* : MModule */;
 344 val* var14 /* : MModule */;
 345 val* var15 /* : MType */;
 346 val* var16 /* : MType */;
 347 short int var17 /* : Bool */;
 348 int cltype;
 349 int idtype;
 350 val* var18 /* : MClass */;
 351 val* var20 /* : MClass */;
 352 val* var21 /* : MClassDef */;
 353 val* var23 /* : MClassDef */;
 354 val* var24 /* : MClassType */;
 355 val* var26 /* : MClassType */;
 356 val* var27 /* : MMethod */;
 357 val* var29 /* : MMethod */;
 358 val* var_mproperty /* var mproperty: MMethod */;
 359 val* var30 /* : HashMap2[MType, MProperty, Set[MMethodDef]] */;
 360 val* var32 /* : HashMap2[MType, MProperty, Set[MMethodDef]] */;
 361 val* var33 /* : nullable Object */;
 362 val* var_res /* var res: nullable Set[MMethodDef] */;
 363 short int var34 /* : Bool */;
 364 short int var35 /* : Bool */;
 365 short int var37 /* : Bool */;
 366 short int var38 /* : Bool */;
 367 val* var39 /* : ArraySet[MMethodDef] */;
 368 val* var40 /* : HashMap2[MType, MProperty, Set[MMethodDef]] */;
 369 val* var42 /* : HashMap2[MType, MProperty, Set[MMethodDef]] */;
 370 val* var43 /* : HashSet[MClass] */;
 371 val* var45 /* : HashSet[MClass] */;
 372 val* var_ /* var : HashSet[MClass] */;
 373 val* var46 /* : Iterator[nullable Object] */;
 374 val* var_47 /* var : Iterator[MClass] */;
 375 short int var48 /* : Bool */;
 376 val* var49 /* : nullable Object */;
 377 val* var_c /* var c: MClass */;
 378 val* var50 /* : MClassDef */;
 379 val* var52 /* : MClassDef */;
 380 val* var53 /* : MClassType */;
 381 val* var55 /* : MClassType */;
 382 val* var_tc /* var tc: MClassType */;
 383 val* var56 /* : MModule */;
 384 val* var58 /* : MModule */;
 385 short int var59 /* : Bool */;
 386 short int var60 /* : Bool */;
 387 val* var61 /* : MModule */;
 388 val* var63 /* : MModule */;
 389 val* var64 /* : MPropDef */;
 390 val* var_d /* var d: MMethodDef */;
 391 var_callsite = p0;
 392 {
 393 { /* Inline typing#CallSite#recv (var_callsite) on <var_callsite:CallSite> */
 394 var3 = var_callsite->attrs[COLOR_nit__typing__CallSite___recv].val; /* _recv on <var_callsite:CallSite> */
 395 if (unlikely(var3 == NULL)) {
 396 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _recv");
 397 PRINT_ERROR(" (%s:%d)\n", FILE_nit__typing, 610);
 398 fatal_exit(1);
 399 }
 400 var1 = var3;
 401 RET_LABEL2:(void)0;
 402 }
 403 }
 404 var_mtype = var1;
 405 {
 406 { /* Inline typing#CallSite#anchor (var_callsite) on <var_callsite:CallSite> */
 407 var6 = var_callsite->attrs[COLOR_nit__typing__CallSite___anchor].val; /* _anchor on <var_callsite:CallSite> */
 408 var4 = var6;
 409 RET_LABEL5:(void)0;
 410 }
 411 }
 412 var_anchor = var4;
 413 if (var_anchor == NULL) {
 414 var7 = 0; /* is null */
 415 } else {
 416 var7 = 1; /* arg is null and recv is not */
 417 }
 418 if (0) {
 419 { /* Inline kernel#Object#!= (var_anchor,((val*)NULL)) on <var_anchor:nullable MClassType> */
 420 var_other = ((val*)NULL);
 421 {
 422 var10 = ((short int(*)(val* self, val* p0))(var_anchor->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_anchor, var_other); /* == on <var_anchor:nullable MClassType(MClassType)>*/
 423 }
 424 var11 = !var10;
 425 var8 = var11;
 426 goto RET_LABEL9;
 427 RET_LABEL9:(void)0;
 428 }
 429 var7 = var8;
 430 }
 431 if (var7){
 432 {
 433 { /* Inline typing#CallSite#mmodule (var_callsite) on <var_callsite:CallSite> */
 434 var14 = var_callsite->attrs[COLOR_nit__typing__CallSite___mmodule].val; /* _mmodule on <var_callsite:CallSite> */
 435 if (unlikely(var14 == NULL)) {
 436 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mmodule");
 437 PRINT_ERROR(" (%s:%d)\n", FILE_nit__typing, 613);
 438 fatal_exit(1);
 439 }
 440 var12 = var14;
 441 RET_LABEL13:(void)0;
 442 }
 443 }
 444 {
 445 var15 = ((val*(*)(val* self, val* p0, val* p1))(var_mtype->class->vft[COLOR_nit__model__MType__anchor_to]))(var_mtype, var12, var_anchor); /* anchor_to on <var_mtype:MType>*/
 446 }
 447 var_mtype = var15;
 448 } else {
 449 }
 450 {
 451 var16 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nit__model__MType__undecorate]))(var_mtype); /* undecorate on <var_mtype:MType>*/
 452 }
 453 var_mtype = var16;
 454 /* <var_mtype:MType> isa MClassType */
 455 cltype = type_nit__MClassType.color;
 456 idtype = type_nit__MClassType.id;
 457 if(cltype >= var_mtype->type->table_size) {
 458 var17 = 0;
 459 } else {
 460 var17 = var_mtype->type->type_table[cltype] == idtype;
 461 }
 462 if (var17){
 463 {
 464 { /* Inline model#MClassType#mclass (var_mtype) on <var_mtype:MType(MClassType)> */
 465 var20 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on <var_mtype:MType(MClassType)> */
 466 if (unlikely(var20 == NULL)) {
 467 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
 468 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138);
 469 fatal_exit(1);
 470 }
 471 var18 = var20;
 472 RET_LABEL19:(void)0;
 473 }
 474 }
 475 {
 476 { /* Inline model#MClass#intro (var18) on <var18:MClass> */
 477 var23 = var18->attrs[COLOR_nit__model__MClass___intro].val; /* _intro on <var18:MClass> */
 478 if (unlikely(var23 == NULL)) {
 479 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro");
 480 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 460);
 481 fatal_exit(1);
 482 }
 483 var21 = var23;
 484 RET_LABEL22:(void)0;
 485 }
 486 }
 487 {
 488 { /* Inline model#MClassDef#bound_mtype (var21) on <var21:MClassDef> */
 489 var26 = var21->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on <var21:MClassDef> */
 490 if (unlikely(var26 == NULL)) {
 491 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype");
 492 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 556);
 493 fatal_exit(1);
 494 }
 495 var24 = var26;
 496 RET_LABEL25:(void)0;
 497 }
 498 }
 499 var_mtype = var24;
 500 } else {
 501 }
 502 {
 503 { /* Inline typing#CallSite#mproperty (var_callsite) on <var_callsite:CallSite> */
 504 var29 = var_callsite->attrs[COLOR_nit__typing__CallSite___mproperty].val; /* _mproperty on <var_callsite:CallSite> */
 505 if (unlikely(var29 == NULL)) {
 506 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mproperty");
 507 PRINT_ERROR(" (%s:%d)\n", FILE_nit__typing, 624);
 508 fatal_exit(1);
 509 }
 510 var27 = var29;
 511 RET_LABEL28:(void)0;
 512 }
 513 }
 514 var_mproperty = var27;
 515 {
 516 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_targets_cache (self) on <self:RapidTypeAnalysis> */
 517 var32 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_targets_cache].val; /* _live_targets_cache on <self:RapidTypeAnalysis> */
 518 if (unlikely(var32 == NULL)) {
 519 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_targets_cache");
 520 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 88);
 521 fatal_exit(1);
 522 }
 523 var30 = var32;
 524 RET_LABEL31:(void)0;
 525 }
 526 }
 527 {
 528 var33 = more_collections___more_collections__HashMap2____91d_93d(var30, var_mtype, var_mproperty);
 529 }
 530 var_res = var33;
 531 if (var_res == NULL) {
 532 var34 = 0; /* is null */
 533 } else {
 534 var34 = 1; /* arg is null and recv is not */
 535 }
 536 if (0) {
 537 { /* Inline kernel#Object#!= (var_res,((val*)NULL)) on <var_res:nullable Set[MMethodDef]> */
 538 var_other = ((val*)NULL);
 539 {
 540 var37 = ((short int(*)(val* self, val* p0))((((long)var_res&3)?class_info[((long)var_res&3)]:var_res->class)->vft[COLOR_standard__kernel__Object___61d_61d]))(var_res, var_other); /* == on <var_res:nullable Set[MMethodDef](Set[MMethodDef])>*/
 541 }
 542 var38 = !var37;
 543 var35 = var38;
 544 goto RET_LABEL36;
 545 RET_LABEL36:(void)0;
 546 }
 547 var34 = var35;
 548 }
 549 if (var34){
 550 var = var_res;
 551 goto RET_LABEL;
 552 } else {
 553 }
 554 var39 = NEW_standard__ArraySet(&type_standard__ArraySet__nit__MMethodDef);
 555 {
 556 standard___standard__ArraySet___standard__kernel__Object__init(var39); /* Direct call array#ArraySet#init on <var39:ArraySet[MMethodDef]>*/
 557 }
 558 var_res = var39;
 559 {
 560 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_targets_cache (self) on <self:RapidTypeAnalysis> */
 561 var42 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_targets_cache].val; /* _live_targets_cache on <self:RapidTypeAnalysis> */
 562 if (unlikely(var42 == NULL)) {
 563 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_targets_cache");
 564 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 88);
 565 fatal_exit(1);
 566 }
 567 var40 = var42;
 568 RET_LABEL41:(void)0;
 569 }
 570 }
 571 {
 572 more_collections___more_collections__HashMap2____91d_93d_61d(var40, var_mtype, var_mproperty, var_res); /* Direct call more_collections#HashMap2#[]= on <var40:HashMap2[MType, MProperty, Set[MMethodDef]]>*/
 573 }
 574 {
 575 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_classes (self) on <self:RapidTypeAnalysis> */
 576 var45 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_classes].val; /* _live_classes on <self:RapidTypeAnalysis> */
 577 if (unlikely(var45 == NULL)) {
 578 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_classes");
 579 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 69);
 580 fatal_exit(1);
 581 }
 582 var43 = var45;
 583 RET_LABEL44:(void)0;
 584 }
 585 }
 586 var_ = var43;
 587 {
 588 var46 = standard___standard__HashSet___standard__abstract_collection__Collection__iterator(var_);
 589 }
 590 var_47 = var46;
 591 for(;;) {
 592 {
 593 var48 = ((short int(*)(val* self))((((long)var_47&3)?class_info[((long)var_47&3)]:var_47->class)->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_47); /* is_ok on <var_47:Iterator[MClass]>*/
 594 }
 595 if (var48){
 596 {
 597 var49 = ((val*(*)(val* self))((((long)var_47&3)?class_info[((long)var_47&3)]:var_47->class)->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_47); /* item on <var_47:Iterator[MClass]>*/
 598 }
 599 var_c = var49;
 600 {
 601 { /* Inline model#MClass#intro (var_c) on <var_c:MClass> */
 602 var52 = var_c->attrs[COLOR_nit__model__MClass___intro].val; /* _intro on <var_c:MClass> */
 603 if (unlikely(var52 == NULL)) {
 604 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro");
 605 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 460);
 606 fatal_exit(1);
 607 }
 608 var50 = var52;
 609 RET_LABEL51:(void)0;
 610 }
 611 }
 612 {
 613 { /* Inline model#MClassDef#bound_mtype (var50) on <var50:MClassDef> */
 614 var55 = var50->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on <var50:MClassDef> */
 615 if (unlikely(var55 == NULL)) {
 616 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype");
 617 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 556);
 618 fatal_exit(1);
 619 }
 620 var53 = var55;
 621 RET_LABEL54:(void)0;
 622 }
 623 }
 624 var_tc = var53;
 625 {
 626 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (self) on <self:RapidTypeAnalysis> */
 627 var58 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
 628 if (unlikely(var58 == NULL)) {
 629 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
 630 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
 631 fatal_exit(1);
 632 }
 633 var56 = var58;
 634 RET_LABEL57:(void)0;
 635 }
 636 }
 637 {
 638 var59 = nit___nit__MType___is_subtype(var_tc, var56, ((val*)NULL), var_mtype);
 639 }
 640 var60 = !var59;
 641 if (var60){
 642 goto BREAK_label;
 643 } else {
 644 }
 645 {
 646 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (self) on <self:RapidTypeAnalysis> */
 647 var63 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
 648 if (unlikely(var63 == NULL)) {
 649 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
 650 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
 651 fatal_exit(1);
 652 }
 653 var61 = var63;
 654 RET_LABEL62:(void)0;
 655 }
 656 }
 657 {
 658 var64 = nit___nit__MProperty___lookup_first_definition(var_mproperty, var61, var_tc);
 659 }
 660 var_d = var64;
 661 {
 662 standard___standard__ArraySet___standard__abstract_collection__SimpleCollection__add(var_res, var_d); /* Direct call array#ArraySet#add on <var_res:nullable Set[MMethodDef](ArraySet[MMethodDef])>*/
 663 }
 664 BREAK_label: (void)0;
 665 {
 666 ((void(*)(val* self))((((long)var_47&3)?class_info[((long)var_47&3)]:var_47->class)->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_47); /* next on <var_47:Iterator[MClass]>*/
 667 }
 668 } else {
 669 goto BREAK_label65;
 670 }
 671 }
 672 BREAK_label65: (void)0;
 673 {
 674 ((void(*)(val* self))((((long)var_47&3)?class_info[((long)var_47&3)]:var_47->class)->vft[COLOR_standard__abstract_collection__Iterator__finish]))(var_47); /* finish on <var_47:Iterator[MClass]>*/
 675 }
 676 var = var_res;
 677 goto RET_LABEL;
 678 RET_LABEL:;
 679 return var;
 680 }
 681 /* method rapid_type_analysis#RapidTypeAnalysis#live_super_sends for (self: RapidTypeAnalysis): HashSet[MMethodDef] */
 682 val* nit___nit__RapidTypeAnalysis___live_super_sends(val* self) {
 683 val* var /* : HashSet[MMethodDef] */;
 684 val* var1 /* : HashSet[MMethodDef] */;
 685 var1 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_super_sends].val; /* _live_super_sends on <self:RapidTypeAnalysis> */
 686 if (unlikely(var1 == NULL)) {
 687 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_super_sends");
 688 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 114);
 689 fatal_exit(1);
 690 }
 691 var = var1;
 692 RET_LABEL:;
 693 return var;
 694 }
 695 /* method rapid_type_analysis#RapidTypeAnalysis#live_types_to_csv for (self: RapidTypeAnalysis): CsvDocument */
 696 val* nit___nit__RapidTypeAnalysis___live_types_to_csv(val* self) {
 697 val* var /* : CsvDocument */;
 698 val* var1 /* : HashSet[MType] */;
 699 val* var_typeset /* var typeset: HashSet[MType] */;
 700 val* var2 /* : HashSet[MClassType] */;
 701 val* var4 /* : HashSet[MClassType] */;
 702 val* var5 /* : HashSet[MClassType] */;
 703 val* var7 /* : HashSet[MClassType] */;
 704 val* var8 /* : HashSet[MType] */;
 705 val* var10 /* : HashSet[MType] */;
 706 val* var11 /* : HashSet[MType] */;
 707 val* var13 /* : HashSet[MType] */;
 708 val* var14 /* : Array[nullable Object] */;
 709 val* var_types /* var types: Array[MType] */;
 710 val* var15 /* : CachedAlphaComparator */;
 711 val* var17 /* : CsvDocument */;
 712 val* var_res /* var res: CsvDocument */;
 713 val* var19 /* : CsvFormat */;
 714 static val* varonce;
 715 val* var20 /* : String */;
 716 char* var21 /* : NativeString */;
 717 val* var22 /* : FlatString */;
 718 val* var24 /* : Array[String] */;
 719 val* var_ /* var : Array[String] */;
 720 static val* varonce25;
 721 val* var26 /* : String */;
 722 char* var27 /* : NativeString */;
 723 val* var28 /* : FlatString */;
 724 static val* varonce29;
 725 val* var30 /* : String */;
 726 char* var31 /* : NativeString */;
 727 val* var32 /* : FlatString */;
 728 static val* varonce33;
 729 val* var34 /* : String */;
 730 char* var35 /* : NativeString */;
 731 val* var36 /* : FlatString */;
 732 static val* varonce37;
 733 val* var38 /* : String */;
 734 char* var39 /* : NativeString */;
 735 val* var40 /* : FlatString */;
 736 val* var_42 /* var : Array[MType] */;
 737 val* var43 /* : ArrayIterator[nullable Object] */;
 738 val* var_44 /* var : ArrayIterator[MType] */;
 739 short int var45 /* : Bool */;
 740 val* var46 /* : nullable Object */;
 741 val* var_t /* var t: MType */;
 742 short int var47 /* : Bool */;
 743 static val* varonce48;
 744 val* var49 /* : String */;
 745 char* var50 /* : NativeString */;
 746 val* var51 /* : FlatString */;
 747 val* var_reso /* var reso: nullable Object */;
 748 static val* varonce52;
 749 val* var53 /* : String */;
 750 char* var54 /* : NativeString */;
 751 val* var55 /* : FlatString */;
 752 short int var56 /* : Bool */;
 753 short int var57 /* : Bool */;
 754 int cltype;
 755 int idtype;
 756 short int var_58 /* var : Bool */;
 757 short int var59 /* : Bool */;
 758 val* var60 /* : HashSet[MClassType] */;
 759 val* var62 /* : HashSet[MClassType] */;
 760 short int var63 /* : Bool */;
 761 short int var_64 /* var : Bool */;
 762 val* var65 /* : HashSet[MClassType] */;
 763 val* var67 /* : HashSet[MClassType] */;
 764 short int var68 /* : Bool */;
 765 static val* varonce69;
 766 val* var70 /* : String */;
 767 char* var71 /* : NativeString */;
 768 val* var72 /* : FlatString */;
 769 val* var_live /* var live: nullable Object */;
 770 static val* varonce73;
 771 val* var74 /* : String */;
 772 char* var75 /* : NativeString */;
 773 val* var76 /* : FlatString */;
 774 short int var77 /* : Bool */;
 775 val* var78 /* : HashSet[MType] */;
 776 val* var80 /* : HashSet[MType] */;
 777 short int var81 /* : Bool */;
 778 short int var_82 /* var : Bool */;
 779 val* var83 /* : HashSet[MType] */;
 780 val* var85 /* : HashSet[MType] */;
 781 short int var86 /* : Bool */;
 782 static val* varonce87;
 783 val* var88 /* : String */;
 784 char* var89 /* : NativeString */;
 785 val* var90 /* : FlatString */;
 786 val* var_cast /* var cast: nullable Object */;
 787 static val* varonce91;
 788 val* var92 /* : String */;
 789 char* var93 /* : NativeString */;
 790 val* var94 /* : FlatString */;
 791 val* var95 /* : Array[Object] */;
 792 val* var96 /* : NativeArray[Object] */;
 793 var1 = NEW_standard__HashSet(&type_standard__HashSet__nit__MType);
 794 {
 795 standard___standard__HashSet___standard__kernel__Object__init(var1); /* Direct call hash_collection#HashSet#init on <var1:HashSet[MType]>*/
 796 }
 797 var_typeset = var1;
 798 {
 799 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_types (self) on <self:RapidTypeAnalysis> */
 800 var4 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on <self:RapidTypeAnalysis> */
 801 if (unlikely(var4 == NULL)) {
 802 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types");
 803 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 60);
 804 fatal_exit(1);
 805 }
 806 var2 = var4;
 807 RET_LABEL3:(void)0;
 808 }
 809 }
 810 {
 811 standard___standard__SimpleCollection___add_all(var_typeset, var2); /* Direct call abstract_collection#SimpleCollection#add_all on <var_typeset:HashSet[MType]>*/
 812 }
 813 {
 814 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_open_types (self) on <self:RapidTypeAnalysis> */
 815 var7 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_open_types].val; /* _live_open_types on <self:RapidTypeAnalysis> */
 816 if (unlikely(var7 == NULL)) {
 817 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_open_types");
 818 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 65);
 819 fatal_exit(1);
 820 }
 821 var5 = var7;
 822 RET_LABEL6:(void)0;
 823 }
 824 }
 825 {
 826 standard___standard__SimpleCollection___add_all(var_typeset, var5); /* Direct call abstract_collection#SimpleCollection#add_all on <var_typeset:HashSet[MType]>*/
 827 }
 828 {
 829 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_cast_types (self) on <self:RapidTypeAnalysis> */
 830 var10 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_cast_types].val; /* _live_cast_types on <self:RapidTypeAnalysis> */
 831 if (unlikely(var10 == NULL)) {
 832 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_cast_types");
 833 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 72);
 834 fatal_exit(1);
 835 }
 836 var8 = var10;
 837 RET_LABEL9:(void)0;
 838 }
 839 }
 840 {
 841 standard___standard__SimpleCollection___add_all(var_typeset, var8); /* Direct call abstract_collection#SimpleCollection#add_all on <var_typeset:HashSet[MType]>*/
 842 }
 843 {
 844 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_open_cast_types (self) on <self:RapidTypeAnalysis> */
 845 var13 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_open_cast_types].val; /* _live_open_cast_types on <self:RapidTypeAnalysis> */
 846 if (unlikely(var13 == NULL)) {
 847 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_open_cast_types");
 848 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 75);
 849 fatal_exit(1);
 850 }
 851 var11 = var13;
 852 RET_LABEL12:(void)0;
 853 }
 854 }
 855 {
 856 standard___standard__SimpleCollection___add_all(var_typeset, var11); /* Direct call abstract_collection#SimpleCollection#add_all on <var_typeset:HashSet[MType]>*/
 857 }
 858 {
 859 var14 = standard__array___Collection___to_a(var_typeset);
 860 }
 861 var_types = var14;
 862 var15 = NEW_standard__CachedAlphaComparator(&type_standard__CachedAlphaComparator);
 863 {
 864 { /* Inline kernel#Object#init (var15) on <var15:CachedAlphaComparator> */
 865 RET_LABEL16:(void)0;
 866 }
 867 }
 868 {
 869 standard___standard__Comparator___sort(var15, var_types); /* Direct call sorter#Comparator#sort on <var15:CachedAlphaComparator>*/
 870 }
 871 var17 = NEW_csv__CsvDocument(&type_csv__CsvDocument);
 872 {
 873 { /* Inline kernel#Object#init (var17) on <var17:CsvDocument> */
 874 RET_LABEL18:(void)0;
 875 }
 876 }
 877 var_res = var17;
 878 var19 = NEW_csv__CsvFormat(&type_csv__CsvFormat);
 879 if (likely(varonce!=NULL)) {
 880 var20 = varonce;
 881 } else {
 882 var21 = "\n";
 883 var22 = standard___standard__NativeString___to_s_with_length(var21, 1l);
 884 var20 = var22;
 885 varonce = var20;
 886 }
 887 {
 888 ((void(*)(val* self, uint32_t p0))(var19->class->vft[COLOR_csv__CsvFormat__delimiter_61d]))(var19, '\"'); /* delimiter= on <var19:CsvFormat>*/
 889 }
 890 {
 891 ((void(*)(val* self, uint32_t p0))(var19->class->vft[COLOR_csv__CsvFormat__separator_61d]))(var19, ';'); /* separator= on <var19:CsvFormat>*/
 892 }
 893 {
 894 ((void(*)(val* self, val* p0))(var19->class->vft[COLOR_csv__CsvFormat__eol_61d]))(var19, var20); /* eol= on <var19:CsvFormat>*/
 895 }
 896 {
 897 ((void(*)(val* self))(var19->class->vft[COLOR_standard__kernel__Object__init]))(var19); /* init on <var19:CsvFormat>*/
 898 }
 899 {
 900 { /* Inline csv#CsvDocument#format= (var_res,var19) on <var_res:CsvDocument> */
 901 var_res->attrs[COLOR_csv__CsvDocument___format].val = var19; /* _format on <var_res:CsvDocument> */
 902 RET_LABEL23:(void)0;
 903 }
 904 }
 905 var24 = NEW_standard__Array(&type_standard__Array__standard__String);
 906 {
 907 standard___standard__Array___with_capacity(var24, 4l); /* Direct call array#Array#with_capacity on <var24:Array[String]>*/
 908 }
 909 var_ = var24;
 910 if (likely(varonce25!=NULL)) {
 911 var26 = varonce25;
 912 } else {
 913 var27 = "Type";
 914 var28 = standard___standard__NativeString___to_s_with_length(var27, 4l);
 915 var26 = var28;
 916 varonce25 = var26;
 917 }
 918 {
 919 standard___standard__AbstractArray___standard__abstract_collection__Sequence__push(var_, var26); /* Direct call array#AbstractArray#push on <var_:Array[String]>*/
 920 }
 921 if (likely(varonce29!=NULL)) {
 922 var30 = varonce29;
 923 } else {
 924 var31 = "Resolution";
 925 var32 = standard___standard__NativeString___to_s_with_length(var31, 10l);
 926 var30 = var32;
 927 varonce29 = var30;
 928 }
 929 {
 930 standard___standard__AbstractArray___standard__abstract_collection__Sequence__push(var_, var30); /* Direct call array#AbstractArray#push on <var_:Array[String]>*/
 931 }
 932 if (likely(varonce33!=NULL)) {
 933 var34 = varonce33;
 934 } else {
 935 var35 = "Liveness";
 936 var36 = standard___standard__NativeString___to_s_with_length(var35, 8l);
 937 var34 = var36;
 938 varonce33 = var34;
 939 }
 940 {
 941 standard___standard__AbstractArray___standard__abstract_collection__Sequence__push(var_, var34); /* Direct call array#AbstractArray#push on <var_:Array[String]>*/
 942 }
 943 if (likely(varonce37!=NULL)) {
 944 var38 = varonce37;
 945 } else {
 946 var39 = "Cast-liveness";
 947 var40 = standard___standard__NativeString___to_s_with_length(var39, 13l);
 948 var38 = var40;
 949 varonce37 = var38;
 950 }
 951 {
 952 standard___standard__AbstractArray___standard__abstract_collection__Sequence__push(var_, var38); /* Direct call array#AbstractArray#push on <var_:Array[String]>*/
 953 }
 954 {
 955 { /* Inline csv#CsvDocument#header= (var_res,var_) on <var_res:CsvDocument> */
 956 var_res->attrs[COLOR_csv__CsvDocument___header].val = var_; /* _header on <var_res:CsvDocument> */
 957 RET_LABEL41:(void)0;
 958 }
 959 }
 960 var_42 = var_types;
 961 {
 962 var43 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_42);
 963 }
 964 var_44 = var43;
 965 for(;;) {
 966 {
 967 var45 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_44);
 968 }
 969 if (var45){
 970 {
 971 var46 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_44);
 972 }
 973 var_t = var46;
 974 {
 975 var47 = ((short int(*)(val* self))(var_t->class->vft[COLOR_nit__model__MType__need_anchor]))(var_t); /* need_anchor on <var_t:MType>*/
 976 }
 977 if (var47){
 978 if (likely(varonce48!=NULL)) {
 979 var49 = varonce48;
 980 } else {
 981 var50 = "OPEN ";
 982 var51 = standard___standard__NativeString___to_s_with_length(var50, 5l);
 983 var49 = var51;
 984 varonce48 = var49;
 985 }
 986 var_reso = var49;
 987 } else {
 988 if (likely(varonce52!=NULL)) {
 989 var53 = varonce52;
 990 } else {
 991 var54 = "CLOSED";
 992 var55 = standard___standard__NativeString___to_s_with_length(var54, 6l);
 993 var53 = var55;
 994 varonce52 = var53;
 995 }
 996 var_reso = var53;
 997 }
 998 /* <var_t:MType> isa MClassType */
 999 cltype = type_nit__MClassType.color;
1000 idtype = type_nit__MClassType.id;
1001 if(cltype >= var_t->type->table_size) {
1002 var57 = 0;
1003 } else {
1004 var57 = var_t->type->type_table[cltype] == idtype;
1005 }
1006 var_58 = var57;
1007 if (var57){
1008 {
1009 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_types (self) on <self:RapidTypeAnalysis> */
1010 var62 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on <self:RapidTypeAnalysis> */
1011 if (unlikely(var62 == NULL)) {
1012 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types");
1013 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 60);
1014 fatal_exit(1);
1015 }
1016 var60 = var62;
1017 RET_LABEL61:(void)0;
1018 }
1019 }
1020 {
1021 var63 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var60, var_t);
1022 }
1023 var_64 = var63;
1024 if (var63){
1025 var59 = var_64;
1026 } else {
1027 {
1028 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_open_types (self) on <self:RapidTypeAnalysis> */
1029 var67 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_open_types].val; /* _live_open_types on <self:RapidTypeAnalysis> */
1030 if (unlikely(var67 == NULL)) {
1031 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_open_types");
1032 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 65);
1033 fatal_exit(1);
1034 }
1035 var65 = var67;
1036 RET_LABEL66:(void)0;
1037 }
1038 }
1039 {
1040 var68 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var65, var_t);
1041 }
1042 var59 = var68;
1043 }
1044 var56 = var59;
1045 } else {
1046 var56 = var_58;
1047 }
1048 if (var56){
1049 if (likely(varonce69!=NULL)) {
1050 var70 = varonce69;
1051 } else {
1052 var71 = "LIVE";
1053 var72 = standard___standard__NativeString___to_s_with_length(var71, 4l);
1054 var70 = var72;
1055 varonce69 = var70;
1056 }
1057 var_live = var70;
1058 } else {
1059 if (likely(varonce73!=NULL)) {
1060 var74 = varonce73;
1061 } else {
1062 var75 = "DEAD";
1063 var76 = standard___standard__NativeString___to_s_with_length(var75, 4l);
1064 var74 = var76;
1065 varonce73 = var74;
1066 }
1067 var_live = var74;
1068 }
1069 {
1070 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_cast_types (self) on <self:RapidTypeAnalysis> */
1071 var80 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_cast_types].val; /* _live_cast_types on <self:RapidTypeAnalysis> */
1072 if (unlikely(var80 == NULL)) {
1073 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_cast_types");
1074 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 72);
1075 fatal_exit(1);
1076 }
1077 var78 = var80;
1078 RET_LABEL79:(void)0;
1079 }
1080 }
1081 {
1082 var81 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var78, var_t);
1083 }
1084 var_82 = var81;
1085 if (var81){
1086 var77 = var_82;
1087 } else {
1088 {
1089 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_open_cast_types (self) on <self:RapidTypeAnalysis> */
1090 var85 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_open_cast_types].val; /* _live_open_cast_types on <self:RapidTypeAnalysis> */
1091 if (unlikely(var85 == NULL)) {
1092 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_open_cast_types");
1093 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 75);
1094 fatal_exit(1);
1095 }
1096 var83 = var85;
1097 RET_LABEL84:(void)0;
1098 }
1099 }
1100 {
1101 var86 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var83, var_t);
1102 }
1103 var77 = var86;
1104 }
1105 if (var77){
1106 if (likely(varonce87!=NULL)) {
1107 var88 = varonce87;
1108 } else {
1109 var89 = "CAST LIVE";
1110 var90 = standard___standard__NativeString___to_s_with_length(var89, 9l);
1111 var88 = var90;
1112 varonce87 = var88;
1113 }
1114 var_cast = var88;
1115 } else {
1116 if (likely(varonce91!=NULL)) {
1117 var92 = varonce91;
1118 } else {
1119 var93 = "CAST DEAD";
1120 var94 = standard___standard__NativeString___to_s_with_length(var93, 9l);
1121 var92 = var94;
1122 varonce91 = var92;
1123 }
1124 var_cast = var92;
1125 }
1126 var95 = NEW_standard__Array(&type_standard__Array__standard__Object);
1127 { /* var95 = array_instance Array[Object] */
1128 var96 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__Object);
1129 ((struct instance_standard__NativeArray*)var96)->values[0] = (val*) var_t;
1130 ((struct instance_standard__NativeArray*)var96)->values[1] = (val*) var_reso;
1131 ((struct instance_standard__NativeArray*)var96)->values[2] = (val*) var_live;
1132 ((struct instance_standard__NativeArray*)var96)->values[3] = (val*) var_cast;
1133 {
1134 ((void(*)(val* self, val* p0, long p1))(var95->class->vft[COLOR_standard__array__Array__with_native]))(var95, var96, 4l); /* with_native on <var95:Array[Object]>*/
1135 }
1136 }
1137 {
1138 csv___csv__CsvDocument___add_record(var_res, var95); /* Direct call csv#CsvDocument#add_record on <var_res:CsvDocument>*/
1139 }
1140 {
1141 standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_44); /* Direct call array#ArrayIterator#next on <var_44:ArrayIterator[MType]>*/
1142 }
1143 } else {
1144 goto BREAK_label;
1145 }
1146 }
1147 BREAK_label: (void)0;
1148 {
1149 standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__finish(var_44); /* Direct call array#ArrayIterator#finish on <var_44:ArrayIterator[MType]>*/
1150 }
1151 var = var_res;
1152 goto RET_LABEL;
1153 RET_LABEL:;
1154 return var;
1155 }
1156 /* method rapid_type_analysis#RapidTypeAnalysis#live_methods_to_tree for (self: RapidTypeAnalysis): OrderedTree[Object] */
1157 val* nit___nit__RapidTypeAnalysis___live_methods_to_tree(val* self) {
1158 val* var /* : OrderedTree[Object] */;
1159 val* var1 /* : OrderedTree[Object] */;
1160 val* var_tree /* var tree: OrderedTree[Object] */;
1161 val* var3 /* : HashSet[MMethod] */;
1162 val* var5 /* : HashSet[MMethod] */;
1163 val* var_ /* var : HashSet[MMethod] */;
1164 val* var6 /* : Iterator[nullable Object] */;
1165 val* var_7 /* var : Iterator[MMethod] */;
1166 short int var8 /* : Bool */;
1167 val* var9 /* : nullable Object */;
1168 val* var_x /* var x: MMethod */;
1169 val* var10 /* : String */;
1170 val* var_xn /* var xn: String */;
1171 val* var11 /* : Array[MPropDef] */;
1172 val* var13 /* : Array[MPropDef] */;
1173 val* var_14 /* var : Array[MMethodDef] */;
1174 val* var15 /* : ArrayIterator[nullable Object] */;
1175 val* var_16 /* var : ArrayIterator[MMethodDef] */;
1176 short int var17 /* : Bool */;
1177 val* var18 /* : nullable Object */;
1178 val* var_z /* var z: MMethodDef */;
1179 val* var19 /* : String */;
1180 val* var21 /* : String */;
1181 val* var_zn /* var zn: String */;
1182 val* var22 /* : HashSet[MMethodDef] */;
1183 val* var24 /* : HashSet[MMethodDef] */;
1184 short int var25 /* : Bool */;
1185 val* var26 /* : HashSet[MMethodDef] */;
1186 val* var28 /* : HashSet[MMethodDef] */;
1187 short int var29 /* : Bool */;
1188 static val* varonce;
1189 val* var30 /* : String */;
1190 char* var31 /* : NativeString */;
1191 val* var32 /* : FlatString */;
1192 val* var33 /* : String */;
1193 val* var34 /* : HashSet[MMethodDef] */;
1194 val* var36 /* : HashSet[MMethodDef] */;
1195 short int var37 /* : Bool */;
1196 static val* varonce38;
1197 val* var39 /* : String */;
1198 char* var40 /* : NativeString */;
1199 val* var41 /* : FlatString */;
1200 val* var42 /* : String */;
1201 val* var44 /* : Sys */;
1202 val* var45 /* : Comparator */;
1203 var1 = NEW_ordered_tree__OrderedTree(&type_ordered_tree__OrderedTree__standard__Object);
1204 {
1205 { /* Inline kernel#Object#init (var1) on <var1:OrderedTree[Object]> */
1206 RET_LABEL2:(void)0;
1207 }
1208 }
1209 var_tree = var1;
1210 {
1211 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_methods (self) on <self:RapidTypeAnalysis> */
1212 var5 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_methods].val; /* _live_methods on <self:RapidTypeAnalysis> */
1213 if (unlikely(var5 == NULL)) {
1214 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_methods");
1215 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 82);
1216 fatal_exit(1);
1217 }
1218 var3 = var5;
1219 RET_LABEL4:(void)0;
1220 }
1221 }
1222 var_ = var3;
1223 {
1224 var6 = standard___standard__HashSet___standard__abstract_collection__Collection__iterator(var_);
1225 }
1226 var_7 = var6;
1227 for(;;) {
1228 {
1229 var8 = ((short int(*)(val* self))((((long)var_7&3)?class_info[((long)var_7&3)]:var_7->class)->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_7); /* is_ok on <var_7:Iterator[MMethod]>*/
1230 }
1231 if (var8){
1232 {
1233 var9 = ((val*(*)(val* self))((((long)var_7&3)?class_info[((long)var_7&3)]:var_7->class)->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_7); /* item on <var_7:Iterator[MMethod]>*/
1234 }
1235 var_x = var9;
1236 {
1237 var10 = nit___nit__MProperty___nit__model_base__MEntity__full_name(var_x);
1238 }
1239 var_xn = var10;
1240 {
1241 ordered_tree___ordered_tree__OrderedTree___add(var_tree, ((val*)NULL), var_xn); /* Direct call ordered_tree#OrderedTree#add on <var_tree:OrderedTree[Object]>*/
1242 }
1243 {
1244 { /* Inline model#MProperty#mpropdefs (var_x) on <var_x:MMethod> */
1245 var13 = var_x->attrs[COLOR_nit__model__MProperty___mpropdefs].val; /* _mpropdefs on <var_x:MMethod> */
1246 if (unlikely(var13 == NULL)) {
1247 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdefs");
1248 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1963);
1249 fatal_exit(1);
1250 }
1251 var11 = var13;
1252 RET_LABEL12:(void)0;
1253 }
1254 }
1255 var_14 = var11;
1256 {
1257 var15 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_14);
1258 }
1259 var_16 = var15;
1260 for(;;) {
1261 {
1262 var17 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_16);
1263 }
1264 if (var17){
1265 {
1266 var18 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_16);
1267 }
1268 var_z = var18;
1269 {
1270 { /* Inline model#MPropDef#to_s (var_z) on <var_z:MMethodDef> */
1271 var21 = var_z->attrs[COLOR_nit__model__MPropDef___to_s].val; /* _to_s on <var_z:MMethodDef> */
1272 if (unlikely(var21 == NULL)) {
1273 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _to_s");
1274 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2303);
1275 fatal_exit(1);
1276 }
1277 var19 = var21;
1278 RET_LABEL20:(void)0;
1279 }
1280 }
1281 var_zn = var19;
1282 {
1283 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_methoddefs (self) on <self:RapidTypeAnalysis> */
1284 var24 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_methoddefs].val; /* _live_methoddefs on <self:RapidTypeAnalysis> */
1285 if (unlikely(var24 == NULL)) {
1286 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_methoddefs");
1287 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 79);
1288 fatal_exit(1);
1289 }
1290 var22 = var24;
1291 RET_LABEL23:(void)0;
1292 }
1293 }
1294 {
1295 var25 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var22, var_z);
1296 }
1297 if (var25){
1298 {
1299 ordered_tree___ordered_tree__OrderedTree___add(var_tree, var_xn, var_zn); /* Direct call ordered_tree#OrderedTree#add on <var_tree:OrderedTree[Object]>*/
1300 }
1301 {
1302 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_super_sends (self) on <self:RapidTypeAnalysis> */
1303 var28 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_super_sends].val; /* _live_super_sends on <self:RapidTypeAnalysis> */
1304 if (unlikely(var28 == NULL)) {
1305 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_super_sends");
1306 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 114);
1307 fatal_exit(1);
1308 }
1309 var26 = var28;
1310 RET_LABEL27:(void)0;
1311 }
1312 }
1313 {
1314 var29 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var26, var_z);
1315 }
1316 if (var29){
1317 if (likely(varonce!=NULL)) {
1318 var30 = varonce;
1319 } else {
1320 var31 = "(super)";
1321 var32 = standard___standard__NativeString___to_s_with_length(var31, 7l);
1322 var30 = var32;
1323 varonce = var30;
1324 }
1325 {
1326 var33 = ((val*(*)(val* self, val* p0))(var_zn->class->vft[COLOR_standard__string__String___43d]))(var_zn, var30); /* + on <var_zn:String>*/
1327 }
1328 {
1329 ordered_tree___ordered_tree__OrderedTree___add(var_tree, var_zn, var33); /* Direct call ordered_tree#OrderedTree#add on <var_tree:OrderedTree[Object]>*/
1330 }
1331 } else {
1332 }
1333 } else {
1334 {
1335 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_super_sends (self) on <self:RapidTypeAnalysis> */
1336 var36 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_super_sends].val; /* _live_super_sends on <self:RapidTypeAnalysis> */
1337 if (unlikely(var36 == NULL)) {
1338 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_super_sends");
1339 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 114);
1340 fatal_exit(1);
1341 }
1342 var34 = var36;
1343 RET_LABEL35:(void)0;
1344 }
1345 }
1346 {
1347 var37 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var34, var_z);
1348 }
1349 if (var37){
1350 if (likely(varonce38!=NULL)) {
1351 var39 = varonce38;
1352 } else {
1353 var40 = "(super)";
1354 var41 = standard___standard__NativeString___to_s_with_length(var40, 7l);
1355 var39 = var41;
1356 varonce38 = var39;
1357 }
1358 {
1359 var42 = ((val*(*)(val* self, val* p0))(var_zn->class->vft[COLOR_standard__string__String___43d]))(var_zn, var39); /* + on <var_zn:String>*/
1360 }
1361 {
1362 ordered_tree___ordered_tree__OrderedTree___add(var_tree, var_xn, var42); /* Direct call ordered_tree#OrderedTree#add on <var_tree:OrderedTree[Object]>*/
1363 }
1364 } else {
1365 }
1366 }
1367 {
1368 standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_16); /* Direct call array#ArrayIterator#next on <var_16:ArrayIterator[MMethodDef]>*/
1369 }
1370 } else {
1371 goto BREAK_label;
1372 }
1373 }
1374 BREAK_label: (void)0;
1375 {
1376 standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__finish(var_16); /* Direct call array#ArrayIterator#finish on <var_16:ArrayIterator[MMethodDef]>*/
1377 }
1378 {
1379 ((void(*)(val* self))((((long)var_7&3)?class_info[((long)var_7&3)]:var_7->class)->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_7); /* next on <var_7:Iterator[MMethod]>*/
1380 }
1381 } else {
1382 goto BREAK_label43;
1383 }
1384 }
1385 BREAK_label43: (void)0;
1386 {
1387 ((void(*)(val* self))((((long)var_7&3)?class_info[((long)var_7&3)]:var_7->class)->vft[COLOR_standard__abstract_collection__Iterator__finish]))(var_7); /* finish on <var_7:Iterator[MMethod]>*/
1388 }
1389 var44 = glob_sys;
1390 {
1391 var45 = standard__string___Sys___alpha_comparator(var44);
1392 }
1393 {
1394 ordered_tree___ordered_tree__OrderedTree___sort_with(var_tree, var45); /* Direct call ordered_tree#OrderedTree#sort_with on <var_tree:OrderedTree[Object]>*/
1395 }
1396 var = var_tree;
1397 goto RET_LABEL;
1398 RET_LABEL:;
1399 return var;
1400 }
1401 /* method rapid_type_analysis#RapidTypeAnalysis#totry_methods for (self: RapidTypeAnalysis): HashSet[MMethod] */
1402 val* nit___nit__RapidTypeAnalysis___totry_methods(val* self) {
1403 val* var /* : HashSet[MMethod] */;
1404 val* var1 /* : HashSet[MMethod] */;
1405 var1 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___totry_methods].val; /* _totry_methods on <self:RapidTypeAnalysis> */
1406 if (unlikely(var1 == NULL)) {
1407 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _totry_methods");
1408 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 169);
1409 fatal_exit(1);
1410 }
1411 var = var1;
1412 RET_LABEL:;
1413 return var;
1414 }
1415 /* method rapid_type_analysis#RapidTypeAnalysis#totry_methods_to_remove for (self: RapidTypeAnalysis): Array[MMethod] */
1416 val* nit___nit__RapidTypeAnalysis___totry_methods_to_remove(val* self) {
1417 val* var /* : Array[MMethod] */;
1418 val* var1 /* : Array[MMethod] */;
1419 var1 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___totry_methods_to_remove].val; /* _totry_methods_to_remove on <self:RapidTypeAnalysis> */
1420 if (unlikely(var1 == NULL)) {
1421 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _totry_methods_to_remove");
1422 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 172);
1423 fatal_exit(1);
1424 }
1425 var = var1;
1426 RET_LABEL:;
1427 return var;
1428 }
1429 /* method rapid_type_analysis#RapidTypeAnalysis#try_methods for (self: RapidTypeAnalysis): HashSet[MMethod] */
1430 val* nit___nit__RapidTypeAnalysis___try_methods(val* self) {
1431 val* var /* : HashSet[MMethod] */;
1432 val* var1 /* : HashSet[MMethod] */;
1433 var1 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___try_methods].val; /* _try_methods on <self:RapidTypeAnalysis> */
1434 if (unlikely(var1 == NULL)) {
1435 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _try_methods");
1436 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 175);
1437 fatal_exit(1);
1438 }
1439 var = var1;
1440 RET_LABEL:;
1441 return var;
1442 }
1443 /* method rapid_type_analysis#RapidTypeAnalysis#todo for (self: RapidTypeAnalysis): List[MMethodDef] */
1444 val* nit___nit__RapidTypeAnalysis___todo(val* self) {
1445 val* var /* : List[MMethodDef] */;
1446 val* var1 /* : List[MMethodDef] */;
1447 var1 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___todo].val; /* _todo on <self:RapidTypeAnalysis> */
1448 if (unlikely(var1 == NULL)) {
1449 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _todo");
1450 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 179);
1451 fatal_exit(1);
1452 }
1453 var = var1;
1454 RET_LABEL:;
1455 return var;
1456 }
1457 /* method rapid_type_analysis#RapidTypeAnalysis#force_alive for (self: RapidTypeAnalysis, String) */
1458 void nit___nit__RapidTypeAnalysis___force_alive(val* self, val* p0) {
1459 val* var_classname /* var classname: String */;
1460 val* var /* : ModelBuilder */;
1461 val* var2 /* : ModelBuilder */;
1462 val* var3 /* : Model */;
1463 val* var5 /* : Model */;
1464 val* var6 /* : nullable Array[MClass] */;
1465 val* var_classes /* var classes: nullable Array[MClass] */;
1466 short int var7 /* : Bool */;
1467 short int var8 /* : Bool */;
1468 val* var_other /* var other: nullable Object */;
1469 short int var10 /* : Bool */;
1470 short int var11 /* : Bool */;
1471 val* var_ /* var : Array[MClass] */;
1472 val* var12 /* : ArrayIterator[nullable Object] */;
1473 val* var_13 /* var : ArrayIterator[MClass] */;
1474 short int var14 /* : Bool */;
1475 val* var15 /* : nullable Object */;
1476 val* var_c /* var c: MClass */;
1477 val* var16 /* : MClassType */;
1478 val* var18 /* : MClassType */;
1479 val* var19 /* : MClassType */;
1480 val* var21 /* : MClassType */;
1481 var_classname = p0;
1482 {
1483 { /* Inline rapid_type_analysis#RapidTypeAnalysis#modelbuilder (self) on <self:RapidTypeAnalysis> */
1484 var2 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___modelbuilder].val; /* _modelbuilder on <self:RapidTypeAnalysis> */
1485 if (unlikely(var2 == NULL)) {
1486 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder");
1487 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 53);
1488 fatal_exit(1);
1489 }
1490 var = var2;
1491 RET_LABEL1:(void)0;
1492 }
1493 }
1494 {
1495 { /* Inline modelbuilder_base#ModelBuilder#model (var) on <var:ModelBuilder> */
1496 var5 = var->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___model].val; /* _model on <var:ModelBuilder> */
1497 if (unlikely(var5 == NULL)) {
1498 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _model");
1499 PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 44);
1500 fatal_exit(1);
1501 }
1502 var3 = var5;
1503 RET_LABEL4:(void)0;
1504 }
1505 }
1506 {
1507 var6 = nit__model___Model___get_mclasses_by_name(var3, var_classname);
1508 }
1509 var_classes = var6;
1510 if (var_classes == NULL) {
1511 var7 = 0; /* is null */
1512 } else {
1513 var7 = 1; /* arg is null and recv is not */
1514 }
1515 if (0) {
1516 { /* Inline kernel#Object#!= (var_classes,((val*)NULL)) on <var_classes:nullable Array[MClass]> */
1517 var_other = ((val*)NULL);
1518 {
1519 var10 = ((short int(*)(val* self, val* p0))(var_classes->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_classes, var_other); /* == on <var_classes:nullable Array[MClass](Array[MClass])>*/
1520 }
1521 var11 = !var10;
1522 var8 = var11;
1523 goto RET_LABEL9;
1524 RET_LABEL9:(void)0;
1525 }
1526 var7 = var8;
1527 }
1528 if (var7){
1529 var_ = var_classes;
1530 {
1531 var12 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_);
1532 }
1533 var_13 = var12;
1534 for(;;) {
1535 {
1536 var14 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_13);
1537 }
1538 if (var14){
1539 {
1540 var15 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_13);
1541 }
1542 var_c = var15;
1543 {
1544 { /* Inline model#MClass#mclass_type (var_c) on <var_c:MClass> */
1545 var18 = var_c->attrs[COLOR_nit__model__MClass___mclass_type].val; /* _mclass_type on <var_c:MClass> */
1546 if (unlikely(var18 == NULL)) {
1547 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass_type");
1548 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 484);
1549 fatal_exit(1);
1550 }
1551 var16 = var18;
1552 RET_LABEL17:(void)0;
1553 }
1554 }
1555 {
1556 { /* Inline model#MClass#mclass_type (var_c) on <var_c:MClass> */
1557 var21 = var_c->attrs[COLOR_nit__model__MClass___mclass_type].val; /* _mclass_type on <var_c:MClass> */
1558 if (unlikely(var21 == NULL)) {
1559 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass_type");
1560 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 484);
1561 fatal_exit(1);
1562 }
1563 var19 = var21;
1564 RET_LABEL20:(void)0;
1565 }
1566 }
1567 {
1568 nit___nit__RapidTypeAnalysis___add_new(self, var16, var19); /* Direct call rapid_type_analysis#RapidTypeAnalysis#add_new on <self:RapidTypeAnalysis>*/
1569 }
1570 {
1571 standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_13); /* Direct call array#ArrayIterator#next on <var_13:ArrayIterator[MClass]>*/
1572 }
1573 } else {
1574 goto BREAK_label;
1575 }
1576 }
1577 BREAK_label: (void)0;
1578 {
1579 standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__finish(var_13); /* Direct call array#ArrayIterator#finish on <var_13:ArrayIterator[MClass]>*/
1580 }
1581 } else {
1582 }
1583 RET_LABEL:;
1584 }
1585 /* method rapid_type_analysis#RapidTypeAnalysis#run_analysis for (self: RapidTypeAnalysis) */
1586 void nit___nit__RapidTypeAnalysis___run_analysis(val* self) {
1587 val* var /* : MModule */;
1588 val* var2 /* : MModule */;
1589 val* var3 /* : nullable MClassType */;
1590 val* var_maintype /* var maintype: nullable MClassType */;
1591 short int var4 /* : Bool */;
1592 short int var5 /* : Bool */;
1593 val* var_other /* var other: nullable Object */;
1594 short int var7 /* : Bool */;
1595 short int var9 /* : Bool */;
1596 val* var10 /* : MModule */;
1597 val* var12 /* : MModule */;
1598 static val* varonce;
1599 val* var13 /* : String */;
1600 char* var14 /* : NativeString */;
1601 val* var15 /* : FlatString */;
1602 val* var16 /* : MClass */;
1603 val* var18 /* : MClass */;
1604 val* var19 /* : nullable MMethod */;
1605 val* var_initprop /* var initprop: nullable MMethod */;
1606 short int var20 /* : Bool */;
1607 short int var21 /* : Bool */;
1608 val* var_other23 /* var other: nullable Object */;
1609 short int var24 /* : Bool */;
1610 short int var25 /* : Bool */;
1611 val* var26 /* : nullable MMethod */;
1612 val* var27 /* : MModule */;
1613 val* var29 /* : MModule */;
1614 static val* varonce30;
1615 val* var31 /* : String */;
1616 char* var32 /* : NativeString */;
1617 val* var33 /* : FlatString */;
1618 val* var34 /* : MClass */;
1619 val* var36 /* : MClass */;
1620 val* var37 /* : nullable MMethod */;
1621 val* var38 /* : MModule */;
1622 val* var40 /* : MModule */;
1623 static val* varonce41;
1624 val* var42 /* : String */;
1625 char* var43 /* : NativeString */;
1626 val* var44 /* : FlatString */;
1627 val* var45 /* : MClass */;
1628 val* var47 /* : MClass */;
1629 val* var48 /* : nullable MMethod */;
1630 val* var_mainprop /* var mainprop: nullable MMethod */;
1631 short int var49 /* : Bool */;
1632 short int var50 /* : Bool */;
1633 short int var52 /* : Bool */;
1634 short int var53 /* : Bool */;
1635 val* var54 /* : MModule */;
1636 val* var56 /* : MModule */;
1637 val* var57 /* : nullable MClassType */;
1638 val* var_finalizable_type /* var finalizable_type: nullable MClassType */;
1639 short int var58 /* : Bool */;
1640 short int var59 /* : Bool */;
1641 short int var61 /* : Bool */;
1642 short int var62 /* : Bool */;
1643 val* var63 /* : MModule */;
1644 val* var65 /* : MModule */;
1645 static val* varonce66;
1646 val* var67 /* : String */;
1647 char* var68 /* : NativeString */;
1648 val* var69 /* : FlatString */;
1649 val* var70 /* : MClass */;
1650 val* var72 /* : MClass */;
1651 val* var73 /* : nullable MMethod */;
1652 val* var_finalize_meth /* var finalize_meth: nullable MMethod */;
1653 short int var74 /* : Bool */;
1654 short int var75 /* : Bool */;
1655 short int var77 /* : Bool */;
1656 short int var78 /* : Bool */;
1657 static val* varonce79;
1658 val* var80 /* : String */;
1659 char* var81 /* : NativeString */;
1660 val* var82 /* : FlatString */;
1661 static val* varonce83;
1662 val* var84 /* : String */;
1663 char* var85 /* : NativeString */;
1664 val* var86 /* : FlatString */;
1665 static val* varonce87;
1666 val* var88 /* : String */;
1667 char* var89 /* : NativeString */;
1668 val* var90 /* : FlatString */;
1669 static val* varonce91;
1670 val* var92 /* : String */;
1671 char* var93 /* : NativeString */;
1672 val* var94 /* : FlatString */;
1673 static val* varonce95;
1674 val* var96 /* : String */;
1675 char* var97 /* : NativeString */;
1676 val* var98 /* : FlatString */;
1677 static val* varonce99;
1678 val* var100 /* : String */;
1679 char* var101 /* : NativeString */;
1680 val* var102 /* : FlatString */;
1681 val* var103 /* : List[MMethodDef] */;
1682 val* var105 /* : List[MMethodDef] */;
1683 short int var106 /* : Bool */;
1684 short int var107 /* : Bool */;
1685 val* var108 /* : List[MMethodDef] */;
1686 val* var110 /* : List[MMethodDef] */;
1687 val* var111 /* : nullable Object */;
1688 val* var_mmethoddef /* var mmethoddef: MMethodDef */;
1689 val* var112 /* : MProperty */;
1690 val* var114 /* : MProperty */;
1691 val* var_mmeth /* var mmeth: MMethod */;
1692 val* var115 /* : nullable MSignature */;
1693 val* var117 /* : nullable MSignature */;
1694 val* var_msignature /* var msignature: nullable MSignature */;
1695 short int var118 /* : Bool */;
1696 short int var119 /* : Bool */;
1697 short int var121 /* : Bool */;
1698 short int var123 /* : Bool */;
1699 val* var124 /* : RapidTypeVisitor */;
1700 val* var125 /* : MClassDef */;
1701 val* var127 /* : MClassDef */;
1702 val* var128 /* : MClassType */;
1703 val* var130 /* : MClassType */;
1704 val* var_v /* var v: RapidTypeVisitor */;
1705 long var131 /* : Int */;
1706 long var133 /* : Int */;
1707 long var_vararg_rank /* var vararg_rank: Int */;
1708 long var134 /* : Int */;
1709 long var136 /* : Int */;
1710 short int var137 /* : Bool */;
1711 short int var139 /* : Bool */;
1712 int cltype;
1713 int idtype;
1714 const char* var_class_name;
1715 short int var140 /* : Bool */;
1716 val* var141 /* : ModelBuilder */;
1717 val* var143 /* : ModelBuilder */;
1718 val* var144 /* : nullable ANode */;
1719 val* var_node /* var node: nullable ANode */;
1720 val* var145 /* : Array[MParameter] */;
1721 val* var147 /* : Array[MParameter] */;
1722 val* var148 /* : nullable Object */;
1723 val* var149 /* : MType */;
1724 val* var151 /* : MType */;
1725 val* var_elttype /* var elttype: MType */;
1726 val* var152 /* : MModule */;
1727 val* var154 /* : MModule */;
1728 val* var155 /* : MClassType */;
1729 val* var_vararg /* var vararg: MClassType */;
1730 val* var156 /* : MModule */;
1731 val* var158 /* : MModule */;
1732 val* var159 /* : MClassType */;
1733 val* var_native /* var native: MClassType */;
1734 val* var160 /* : ModelBuilder */;
1735 val* var162 /* : ModelBuilder */;
1736 static val* varonce163;
1737 val* var164 /* : String */;
1738 char* var165 /* : NativeString */;
1739 val* var166 /* : FlatString */;
1740 val* var167 /* : MClass */;
1741 val* var169 /* : MClass */;
1742 val* var170 /* : MModule */;
1743 val* var172 /* : MModule */;
1744 val* var173 /* : MMethod */;
1745 val* var_sig /* var sig: MSignature */;
1746 val* var174 /* : MPropDef */;
1747 val* var176 /* : MPropDef */;
1748 val* var177 /* : nullable MSignature */;
1749 val* var179 /* : nullable MSignature */;
1750 val* var_osig /* var osig: MSignature */;
1751 long var_i /* var i: Int */;
1752 long var180 /* : Int */;
1753 long var_ /* var : Int */;
1754 short int var181 /* : Bool */;
1755 short int var183 /* : Bool */;
1756 int cltype184;
1757 int idtype185;
1758 const char* var_class_name186;
1759 short int var187 /* : Bool */;
1760 val* var188 /* : Array[MParameter] */;
1761 val* var190 /* : Array[MParameter] */;
1762 val* var191 /* : nullable Object */;
1763 val* var192 /* : MType */;
1764 val* var194 /* : MType */;
1765 val* var_origtype /* var origtype: MType */;
1766 short int var195 /* : Bool */;
1767 short int var196 /* : Bool */;
1768 val* var198 /* : Array[MParameter] */;
1769 val* var200 /* : Array[MParameter] */;
1770 val* var201 /* : nullable Object */;
1771 val* var202 /* : MType */;
1772 val* var204 /* : MType */;
1773 val* var_paramtype /* var paramtype: MType */;
1774 long var205 /* : Int */;
1775 val* var207 /* : ModelBuilder */;
1776 val* var209 /* : ModelBuilder */;
1777 val* var210 /* : nullable ANode */;
1778 val* var_npropdef /* var npropdef: nullable ANode */;
1779 short int var211 /* : Bool */;
1780 int cltype212;
1781 int idtype213;
1782 val* var214 /* : nullable MMethodDef */;
1783 val* var216 /* : nullable MMethodDef */;
1784 short int var217 /* : Bool */;
1785 short int var219 /* : Bool */;
1786 short int var221 /* : Bool */;
1787 short int var222 /* : Bool */;
1788 val* var223 /* : MProperty */;
1789 val* var225 /* : MProperty */;
1790 short int var226 /* : Bool */;
1791 short int var228 /* : Bool */;
1792 short int var_229 /* var : Bool */;
1793 short int var230 /* : Bool */;
1794 short int var231 /* : Bool */;
1795 val* var232 /* : MClassType */;
1796 val* var234 /* : MClassType */;
1797 val* var235 /* : nullable Object */;
1798 val* var237 /* : nullable Object */;
1799 short int var238 /* : Bool */;
1800 short int var239 /* : Bool */;
1801 val* var240 /* : nullable MType */;
1802 val* var242 /* : nullable MType */;
1803 short int var243 /* : Bool */;
1804 int cltype244;
1805 int idtype245;
1806 const char* var_class_name246;
1807 short int var247 /* : Bool */;
1808 short int var248 /* : Bool */;
1809 short int var250 /* : Bool */;
1810 short int var252 /* : Bool */;
1811 short int var253 /* : Bool */;
1812 int cltype254;
1813 int idtype255;
1814 val* var256 /* : nullable Array[CallSite] */;
1815 val* var258 /* : nullable Array[CallSite] */;
1816 val* var_auto_super_inits /* var auto_super_inits: nullable Array[CallSite] */;
1817 short int var259 /* : Bool */;
1818 short int var260 /* : Bool */;
1819 short int var262 /* : Bool */;
1820 short int var263 /* : Bool */;
1821 val* var_264 /* var : Array[CallSite] */;
1822 val* var265 /* : ArrayIterator[nullable Object] */;
1823 val* var_266 /* var : ArrayIterator[CallSite] */;
1824 short int var267 /* : Bool */;
1825 val* var268 /* : nullable Object */;
1826 val* var_auto_super_init /* var auto_super_init: CallSite */;
1827 short int var270 /* : Bool */;
1828 short int var272 /* : Bool */;
1829 val* var273 /* : MClassType */;
1830 val* var275 /* : MClassType */;
1831 short int var276 /* : Bool */;
1832 short int var277 /* : Bool */;
1833 short int var279 /* : Bool */;
1834 short int var_280 /* var : Bool */;
1835 short int var281 /* : Bool */;
1836 short int var283 /* : Bool */;
1837 val* var284 /* : nullable MType */;
1838 val* var286 /* : nullable MType */;
1839 val* var_ret /* var ret: nullable MType */;
1840 short int var287 /* : Bool */;
1841 short int var288 /* : Bool */;
1842 short int var289 /* : Bool */;
1843 short int var290 /* : Bool */;
1844 short int var291 /* : Bool */;
1845 short int var293 /* : Bool */;
1846 short int var294 /* : Bool */;
1847 short int var_295 /* var : Bool */;
1848 short int var296 /* : Bool */;
1849 int cltype297;
1850 int idtype298;
1851 short int var_299 /* var : Bool */;
1852 val* var300 /* : MClass */;
1853 val* var302 /* : MClass */;
1854 val* var303 /* : MClassKind */;
1855 val* var305 /* : MClassKind */;
1856 val* var306 /* : Sys */;
1857 val* var307 /* : MClassKind */;
1858 short int var308 /* : Bool */;
1859 short int var310 /* : Bool */;
1860 short int var311 /* : Bool */;
1861 short int var_312 /* var : Bool */;
1862 val* var313 /* : MClass */;
1863 val* var315 /* : MClass */;
1864 val* var316 /* : MClassKind */;
1865 val* var318 /* : MClassKind */;
1866 val* var319 /* : Sys */;
1867 val* var320 /* : MClassKind */;
1868 short int var321 /* : Bool */;
1869 short int var323 /* : Bool */;
1870 short int var324 /* : Bool */;
1871 val* var326 /* : List[MClassType] */;
1872 val* var_todo_types /* var todo_types: List[MClassType] */;
1873 val* var328 /* : HashSet[MClassType] */;
1874 val* var330 /* : HashSet[MClassType] */;
1875 short int var331 /* : Bool */;
1876 short int var332 /* : Bool */;
1877 val* var333 /* : nullable Object */;
1878 val* var_t /* var t: MClassType */;
1879 val* var334 /* : HashSet[MClassType] */;
1880 val* var336 /* : HashSet[MClassType] */;
1881 val* var_337 /* var : HashSet[MClassType] */;
1882 val* var338 /* : Iterator[nullable Object] */;
1883 val* var_339 /* var : Iterator[MClassType] */;
1884 short int var340 /* : Bool */;
1885 val* var341 /* : nullable Object */;
1886 val* var_ot /* var ot: MClassType */;
1887 val* var342 /* : MModule */;
1888 val* var344 /* : MModule */;
1889 short int var345 /* : Bool */;
1890 short int var346 /* : Bool */;
1891 val* var348 /* : MModule */;
1892 val* var350 /* : MModule */;
1893 val* var351 /* : MClassType */;
1894 val* var_rt /* var rt: MClassType */;
1895 val* var352 /* : HashSet[MClassType] */;
1896 val* var354 /* : HashSet[MClassType] */;
1897 short int var355 /* : Bool */;
1898 short int var356 /* : Bool */;
1899 short int var357 /* : Bool */;
1900 val* var358 /* : HashSet[MClassType] */;
1901 val* var360 /* : HashSet[MClassType] */;
1902 val* var363 /* : HashSet[MType] */;
1903 val* var365 /* : HashSet[MType] */;
1904 val* var_366 /* var : HashSet[MType] */;
1905 val* var367 /* : Iterator[nullable Object] */;
1906 val* var_368 /* var : Iterator[MType] */;
1907 short int var369 /* : Bool */;
1908 val* var370 /* : nullable Object */;
1909 val* var_ot371 /* var ot: MType */;
1910 val* var372 /* : HashSet[MClassType] */;
1911 val* var374 /* : HashSet[MClassType] */;
1912 val* var_375 /* var : HashSet[MClassType] */;
1913 val* var376 /* : Iterator[nullable Object] */;
1914 val* var_377 /* var : Iterator[MClassType] */;
1915 short int var378 /* : Bool */;
1916 val* var379 /* : nullable Object */;
1917 val* var_t380 /* var t: MClassType */;
1918 val* var381 /* : MModule */;
1919 val* var383 /* : MModule */;
1920 short int var384 /* : Bool */;
1921 short int var385 /* : Bool */;
1922 val* var387 /* : MModule */;
1923 val* var389 /* : MModule */;
1924 val* var390 /* : MType */;
1925 val* var_rt391 /* var rt: MType */;
1926 val* var392 /* : HashSet[MType] */;
1927 val* var394 /* : HashSet[MType] */;
1928 {
1929 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (self) on <self:RapidTypeAnalysis> */
1930 var2 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
1931 if (unlikely(var2 == NULL)) {
1932 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
1933 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
1934 fatal_exit(1);
1935 }
1936 var = var2;
1937 RET_LABEL1:(void)0;
1938 }
1939 }
1940 {
1941 var3 = nit__model___MModule___sys_type(var);
1942 }
1943 var_maintype = var3;
1944 if (var_maintype == NULL) {
1945 var4 = 1; /* is null */
1946 } else {
1947 var4 = 0; /* arg is null but recv is not */
1948 }
1949 if (0) {
1950 { /* Inline kernel#Object#== (var_maintype,((val*)NULL)) on <var_maintype:nullable MClassType> */
1951 var_other = ((val*)NULL);
1952 {
1953 { /* Inline kernel#Object#is_same_instance (var_maintype,var_other) on <var_maintype:nullable MClassType(MClassType)> */
1954 var9 = var_maintype == var_other;
1955 var7 = var9;
1956 goto RET_LABEL8;
1957 RET_LABEL8:(void)0;
1958 }
1959 }
1960 var5 = var7;
1961 goto RET_LABEL6;
1962 RET_LABEL6:(void)0;
1963 }
1964 var4 = var5;
1965 }
1966 if (var4){
1967 goto RET_LABEL;
1968 } else {
1969 }
1970 {
1971 nit___nit__RapidTypeAnalysis___add_new(self, var_maintype, var_maintype); /* Direct call rapid_type_analysis#RapidTypeAnalysis#add_new on <self:RapidTypeAnalysis>*/
1972 }
1973 {
1974 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (self) on <self:RapidTypeAnalysis> */
1975 var12 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
1976 if (unlikely(var12 == NULL)) {
1977 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
1978 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
1979 fatal_exit(1);
1980 }
1981 var10 = var12;
1982 RET_LABEL11:(void)0;
1983 }
1984 }
1985 if (likely(varonce!=NULL)) {
1986 var13 = varonce;
1987 } else {
1988 var14 = "init";
1989 var15 = standard___standard__NativeString___to_s_with_length(var14, 4l);
1990 var13 = var15;
1991 varonce = var13;
1992 }
1993 {
1994 { /* Inline model#MClassType#mclass (var_maintype) on <var_maintype:nullable MClassType(MClassType)> */
1995 var18 = var_maintype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on <var_maintype:nullable MClassType(MClassType)> */
1996 if (unlikely(var18 == NULL)) {
1997 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
1998 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138);
1999 fatal_exit(1);
2000 }
2001 var16 = var18;
2002 RET_LABEL17:(void)0;
2003 }
2004 }
2005 {
2006 var19 = nit__model___MModule___try_get_primitive_method(var10, var13, var16);
2007 }
2008 var_initprop = var19;
2009 if (var_initprop == NULL) {
2010 var20 = 0; /* is null */
2011 } else {
2012 var20 = 1; /* arg is null and recv is not */
2013 }
2014 if (0) {
2015 { /* Inline kernel#Object#!= (var_initprop,((val*)NULL)) on <var_initprop:nullable MMethod> */
2016 var_other23 = ((val*)NULL);
2017 {
2018 var24 = ((short int(*)(val* self, val* p0))(var_initprop->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_initprop, var_other23); /* == on <var_initprop:nullable MMethod(MMethod)>*/
2019 }
2020 var25 = !var24;
2021 var21 = var25;
2022 goto RET_LABEL22;
2023 RET_LABEL22:(void)0;
2024 }
2025 var20 = var21;
2026 }
2027 if (var20){
2028 {
2029 nit___nit__RapidTypeAnalysis___add_send(self, var_maintype, var_initprop); /* Direct call rapid_type_analysis#RapidTypeAnalysis#add_send on <self:RapidTypeAnalysis>*/
2030 }
2031 } else {
2032 }
2033 {
2034 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (self) on <self:RapidTypeAnalysis> */
2035 var29 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
2036 if (unlikely(var29 == NULL)) {
2037 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
2038 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
2039 fatal_exit(1);
2040 }
2041 var27 = var29;
2042 RET_LABEL28:(void)0;
2043 }
2044 }
2045 if (likely(varonce30!=NULL)) {
2046 var31 = varonce30;
2047 } else {
2048 var32 = "run";
2049 var33 = standard___standard__NativeString___to_s_with_length(var32, 3l);
2050 var31 = var33;
2051 varonce30 = var31;
2052 }
2053 {
2054 { /* Inline model#MClassType#mclass (var_maintype) on <var_maintype:nullable MClassType(MClassType)> */
2055 var36 = var_maintype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on <var_maintype:nullable MClassType(MClassType)> */
2056 if (unlikely(var36 == NULL)) {
2057 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
2058 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138);
2059 fatal_exit(1);
2060 }
2061 var34 = var36;
2062 RET_LABEL35:(void)0;
2063 }
2064 }
2065 {
2066 var37 = nit__model___MModule___try_get_primitive_method(var27, var31, var34);
2067 }
2068 if (var37!=NULL) {
2069 var26 = var37;
2070 } else {
2071 {
2072 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (self) on <self:RapidTypeAnalysis> */
2073 var40 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
2074 if (unlikely(var40 == NULL)) {
2075 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
2076 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
2077 fatal_exit(1);
2078 }
2079 var38 = var40;
2080 RET_LABEL39:(void)0;
2081 }
2082 }
2083 if (likely(varonce41!=NULL)) {
2084 var42 = varonce41;
2085 } else {
2086 var43 = "main";
2087 var44 = standard___standard__NativeString___to_s_with_length(var43, 4l);
2088 var42 = var44;
2089 varonce41 = var42;
2090 }
2091 {
2092 { /* Inline model#MClassType#mclass (var_maintype) on <var_maintype:nullable MClassType(MClassType)> */
2093 var47 = var_maintype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on <var_maintype:nullable MClassType(MClassType)> */
2094 if (unlikely(var47 == NULL)) {
2095 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
2096 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138);
2097 fatal_exit(1);
2098 }
2099 var45 = var47;
2100 RET_LABEL46:(void)0;
2101 }
2102 }
2103 {
2104 var48 = nit__model___MModule___try_get_primitive_method(var38, var42, var45);
2105 }
2106 var26 = var48;
2107 }
2108 var_mainprop = var26;
2109 if (var_mainprop == NULL) {
2110 var49 = 0; /* is null */
2111 } else {
2112 var49 = 1; /* arg is null and recv is not */
2113 }
2114 if (0) {
2115 { /* Inline kernel#Object#!= (var_mainprop,((val*)NULL)) on <var_mainprop:nullable MMethod> */
2116 var_other23 = ((val*)NULL);
2117 {
2118 var52 = ((short int(*)(val* self, val* p0))(var_mainprop->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_mainprop, var_other23); /* == on <var_mainprop:nullable MMethod(MMethod)>*/
2119 }
2120 var53 = !var52;
2121 var50 = var53;
2122 goto RET_LABEL51;
2123 RET_LABEL51:(void)0;
2124 }
2125 var49 = var50;
2126 }
2127 if (var49){
2128 {
2129 nit___nit__RapidTypeAnalysis___add_send(self, var_maintype, var_mainprop); /* Direct call rapid_type_analysis#RapidTypeAnalysis#add_send on <self:RapidTypeAnalysis>*/
2130 }
2131 } else {
2132 }
2133 {
2134 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (self) on <self:RapidTypeAnalysis> */
2135 var56 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
2136 if (unlikely(var56 == NULL)) {
2137 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
2138 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
2139 fatal_exit(1);
2140 }
2141 var54 = var56;
2142 RET_LABEL55:(void)0;
2143 }
2144 }
2145 {
2146 var57 = nit__model___MModule___finalizable_type(var54);
2147 }
2148 var_finalizable_type = var57;
2149 if (var_finalizable_type == NULL) {
2150 var58 = 0; /* is null */
2151 } else {
2152 var58 = 1; /* arg is null and recv is not */
2153 }
2154 if (0) {
2155 { /* Inline kernel#Object#!= (var_finalizable_type,((val*)NULL)) on <var_finalizable_type:nullable MClassType> */
2156 var_other23 = ((val*)NULL);
2157 {
2158 var61 = ((short int(*)(val* self, val* p0))(var_finalizable_type->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_finalizable_type, var_other23); /* == on <var_finalizable_type:nullable MClassType(MClassType)>*/
2159 }
2160 var62 = !var61;
2161 var59 = var62;
2162 goto RET_LABEL60;
2163 RET_LABEL60:(void)0;
2164 }
2165 var58 = var59;
2166 }
2167 if (var58){
2168 {
2169 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (self) on <self:RapidTypeAnalysis> */
2170 var65 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
2171 if (unlikely(var65 == NULL)) {
2172 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
2173 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
2174 fatal_exit(1);
2175 }
2176 var63 = var65;
2177 RET_LABEL64:(void)0;
2178 }
2179 }
2180 if (likely(varonce66!=NULL)) {
2181 var67 = varonce66;
2182 } else {
2183 var68 = "finalize";
2184 var69 = standard___standard__NativeString___to_s_with_length(var68, 8l);
2185 var67 = var69;
2186 varonce66 = var67;
2187 }
2188 {
2189 { /* Inline model#MClassType#mclass (var_finalizable_type) on <var_finalizable_type:nullable MClassType(MClassType)> */
2190 var72 = var_finalizable_type->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on <var_finalizable_type:nullable MClassType(MClassType)> */
2191 if (unlikely(var72 == NULL)) {
2192 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
2193 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138);
2194 fatal_exit(1);
2195 }
2196 var70 = var72;
2197 RET_LABEL71:(void)0;
2198 }
2199 }
2200 {
2201 var73 = nit__model___MModule___try_get_primitive_method(var63, var67, var70);
2202 }
2203 var_finalize_meth = var73;
2204 if (var_finalize_meth == NULL) {
2205 var74 = 0; /* is null */
2206 } else {
2207 var74 = 1; /* arg is null and recv is not */
2208 }
2209 if (0) {
2210 { /* Inline kernel#Object#!= (var_finalize_meth,((val*)NULL)) on <var_finalize_meth:nullable MMethod> */
2211 var_other23 = ((val*)NULL);
2212 {
2213 var77 = ((short int(*)(val* self, val* p0))(var_finalize_meth->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_finalize_meth, var_other23); /* == on <var_finalize_meth:nullable MMethod(MMethod)>*/
2214 }
2215 var78 = !var77;
2216 var75 = var78;
2217 goto RET_LABEL76;
2218 RET_LABEL76:(void)0;
2219 }
2220 var74 = var75;
2221 }
2222 if (var74){
2223 {
2224 nit___nit__RapidTypeAnalysis___add_send(self, var_finalizable_type, var_finalize_meth); /* Direct call rapid_type_analysis#RapidTypeAnalysis#add_send on <self:RapidTypeAnalysis>*/
2225 }
2226 } else {
2227 }
2228 } else {
2229 }
2230 if (likely(varonce79!=NULL)) {
2231 var80 = varonce79;
2232 } else {
2233 var81 = "Bool";
2234 var82 = standard___standard__NativeString___to_s_with_length(var81, 4l);
2235 var80 = var82;
2236 varonce79 = var80;
2237 }
2238 {
2239 nit___nit__RapidTypeAnalysis___force_alive(self, var80); /* Direct call rapid_type_analysis#RapidTypeAnalysis#force_alive on <self:RapidTypeAnalysis>*/
2240 }
2241 if (likely(varonce83!=NULL)) {
2242 var84 = varonce83;
2243 } else {
2244 var85 = "Int";
2245 var86 = standard___standard__NativeString___to_s_with_length(var85, 3l);
2246 var84 = var86;
2247 varonce83 = var84;
2248 }
2249 {
2250 nit___nit__RapidTypeAnalysis___force_alive(self, var84); /* Direct call rapid_type_analysis#RapidTypeAnalysis#force_alive on <self:RapidTypeAnalysis>*/
2251 }
2252 if (likely(varonce87!=NULL)) {
2253 var88 = varonce87;
2254 } else {
2255 var89 = "Float";
2256 var90 = standard___standard__NativeString___to_s_with_length(var89, 5l);
2257 var88 = var90;
2258 varonce87 = var88;
2259 }
2260 {
2261 nit___nit__RapidTypeAnalysis___force_alive(self, var88); /* Direct call rapid_type_analysis#RapidTypeAnalysis#force_alive on <self:RapidTypeAnalysis>*/
2262 }
2263 if (likely(varonce91!=NULL)) {
2264 var92 = varonce91;
2265 } else {
2266 var93 = "Char";
2267 var94 = standard___standard__NativeString___to_s_with_length(var93, 4l);
2268 var92 = var94;
2269 varonce91 = var92;
2270 }
2271 {
2272 nit___nit__RapidTypeAnalysis___force_alive(self, var92); /* Direct call rapid_type_analysis#RapidTypeAnalysis#force_alive on <self:RapidTypeAnalysis>*/
2273 }
2274 if (likely(varonce95!=NULL)) {
2275 var96 = varonce95;
2276 } else {
2277 var97 = "Pointer";
2278 var98 = standard___standard__NativeString___to_s_with_length(var97, 7l);
2279 var96 = var98;
2280 varonce95 = var96;
2281 }
2282 {
2283 nit___nit__RapidTypeAnalysis___force_alive(self, var96); /* Direct call rapid_type_analysis#RapidTypeAnalysis#force_alive on <self:RapidTypeAnalysis>*/
2284 }
2285 if (likely(varonce99!=NULL)) {
2286 var100 = varonce99;
2287 } else {
2288 var101 = "Byte";
2289 var102 = standard___standard__NativeString___to_s_with_length(var101, 4l);
2290 var100 = var102;
2291 varonce99 = var100;
2292 }
2293 {
2294 nit___nit__RapidTypeAnalysis___force_alive(self, var100); /* Direct call rapid_type_analysis#RapidTypeAnalysis#force_alive on <self:RapidTypeAnalysis>*/
2295 }
2296 for(;;) {
2297 {
2298 { /* Inline rapid_type_analysis#RapidTypeAnalysis#todo (self) on <self:RapidTypeAnalysis> */
2299 var105 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___todo].val; /* _todo on <self:RapidTypeAnalysis> */
2300 if (unlikely(var105 == NULL)) {
2301 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _todo");
2302 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 179);
2303 fatal_exit(1);
2304 }
2305 var103 = var105;
2306 RET_LABEL104:(void)0;
2307 }
2308 }
2309 {
2310 var106 = standard___standard__List___standard__abstract_collection__Collection__is_empty(var103);
2311 }
2312 var107 = !var106;
2313 if (var107){
2314 {
2315 { /* Inline rapid_type_analysis#RapidTypeAnalysis#todo (self) on <self:RapidTypeAnalysis> */
2316 var110 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___todo].val; /* _todo on <self:RapidTypeAnalysis> */
2317 if (unlikely(var110 == NULL)) {
2318 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _todo");
2319 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 179);
2320 fatal_exit(1);
2321 }
2322 var108 = var110;
2323 RET_LABEL109:(void)0;
2324 }
2325 }
2326 {
2327 var111 = standard___standard__List___standard__abstract_collection__Sequence__shift(var108);
2328 }
2329 var_mmethoddef = var111;
2330 {
2331 { /* Inline model#MPropDef#mproperty (var_mmethoddef) on <var_mmethoddef:MMethodDef> */
2332 var114 = var_mmethoddef->attrs[COLOR_nit__model__MPropDef___mproperty].val; /* _mproperty on <var_mmethoddef:MMethodDef> */
2333 if (unlikely(var114 == NULL)) {
2334 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mproperty");
2335 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2212);
2336 fatal_exit(1);
2337 }
2338 var112 = var114;
2339 RET_LABEL113:(void)0;
2340 }
2341 }
2342 var_mmeth = var112;
2343 {
2344 { /* Inline model#MMethodDef#msignature (var_mmethoddef) on <var_mmethoddef:MMethodDef> */
2345 var117 = var_mmethoddef->attrs[COLOR_nit__model__MMethodDef___msignature].val; /* _msignature on <var_mmethoddef:MMethodDef> */
2346 var115 = var117;
2347 RET_LABEL116:(void)0;
2348 }
2349 }
2350 var_msignature = var115;
2351 if (var_msignature == NULL) {
2352 var118 = 1; /* is null */
2353 } else {
2354 var118 = 0; /* arg is null but recv is not */
2355 }
2356 if (0) {
2357 { /* Inline kernel#Object#== (var_msignature,((val*)NULL)) on <var_msignature:nullable MSignature> */
2358 var_other = ((val*)NULL);
2359 {
2360 { /* Inline kernel#Object#is_same_instance (var_msignature,var_other) on <var_msignature:nullable MSignature(MSignature)> */
2361 var123 = var_msignature == var_other;
2362 var121 = var123;
2363 goto RET_LABEL122;
2364 RET_LABEL122:(void)0;
2365 }
2366 }
2367 var119 = var121;
2368 goto RET_LABEL120;
2369 RET_LABEL120:(void)0;
2370 }
2371 var118 = var119;
2372 }
2373 if (var118){
2374 goto BREAK_label;
2375 } else {
2376 }
2377 var124 = NEW_nit__RapidTypeVisitor(&type_nit__RapidTypeVisitor);
2378 {
2379 { /* Inline model#MPropDef#mclassdef (var_mmethoddef) on <var_mmethoddef:MMethodDef> */
2380 var127 = var_mmethoddef->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on <var_mmethoddef:MMethodDef> */
2381 if (unlikely(var127 == NULL)) {
2382 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef");
2383 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2209);
2384 fatal_exit(1);
2385 }
2386 var125 = var127;
2387 RET_LABEL126:(void)0;
2388 }
2389 }
2390 {
2391 { /* Inline model#MClassDef#bound_mtype (var125) on <var125:MClassDef> */
2392 var130 = var125->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on <var125:MClassDef> */
2393 if (unlikely(var130 == NULL)) {
2394 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype");
2395 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 556);
2396 fatal_exit(1);
2397 }
2398 var128 = var130;
2399 RET_LABEL129:(void)0;
2400 }
2401 }
2402 {
2403 ((void(*)(val* self, val* p0))(var124->class->vft[COLOR_nit__rapid_type_analysis__RapidTypeVisitor__analysis_61d]))(var124, self); /* analysis= on <var124:RapidTypeVisitor>*/
2404 }
2405 {
2406 ((void(*)(val* self, val* p0))(var124->class->vft[COLOR_nit__rapid_type_analysis__RapidTypeVisitor__receiver_61d]))(var124, var128); /* receiver= on <var124:RapidTypeVisitor>*/
2407 }
2408 {
2409 ((void(*)(val* self, val* p0))(var124->class->vft[COLOR_nit__rapid_type_analysis__RapidTypeVisitor__mpropdef_61d]))(var124, var_mmethoddef); /* mpropdef= on <var124:RapidTypeVisitor>*/
2410 }
2411 {
2412 ((void(*)(val* self))(var124->class->vft[COLOR_standard__kernel__Object__init]))(var124); /* init on <var124:RapidTypeVisitor>*/
2413 }
2414 var_v = var124;
2415 {
2416 { /* Inline model#MSignature#vararg_rank (var_msignature) on <var_msignature:nullable MSignature(MSignature)> */
2417 var133 = var_msignature->attrs[COLOR_nit__model__MSignature___vararg_rank].l; /* _vararg_rank on <var_msignature:nullable MSignature(MSignature)> */
2418 var131 = var133;
2419 RET_LABEL132:(void)0;
2420 }
2421 }
2422 var_vararg_rank = var131;
2423 {
2424 { /* Inline kernel#Int#unary - (1l) on <1l:Int> */
2425 var136 = -1l;
2426 var134 = var136;
2427 goto RET_LABEL135;
2428 RET_LABEL135:(void)0;
2429 }
2430 }
2431 {
2432 { /* Inline kernel#Int#> (var_vararg_rank,var134) on <var_vararg_rank:Int> */
2433 /* Covariant cast for argument 0 (i) <var134:Int> isa OTHER */
2434 /* <var134:Int> isa OTHER */
2435 var139 = 1; /* easy <var134:Int> isa OTHER*/
2436 if (unlikely(!var139)) {
2437 var_class_name = type_standard__Int.name;
2438 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
2439 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 536);
2440 fatal_exit(1);
2441 }
2442 var140 = var_vararg_rank > var134;
2443 var137 = var140;
2444 goto RET_LABEL138;
2445 RET_LABEL138:(void)0;
2446 }
2447 }
2448 if (var137){
2449 {
2450 { /* Inline rapid_type_analysis#RapidTypeAnalysis#modelbuilder (self) on <self:RapidTypeAnalysis> */
2451 var143 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___modelbuilder].val; /* _modelbuilder on <self:RapidTypeAnalysis> */
2452 if (unlikely(var143 == NULL)) {
2453 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder");
2454 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 53);
2455 fatal_exit(1);
2456 }
2457 var141 = var143;
2458 RET_LABEL142:(void)0;
2459 }
2460 }
2461 {
2462 var144 = nit__modelize_property___ModelBuilder___mpropdef2node(var141, var_mmethoddef);
2463 }
2464 var_node = var144;
2465 {
2466 { /* Inline model#MSignature#mparameters (var_msignature) on <var_msignature:nullable MSignature(MSignature)> */
2467 var147 = var_msignature->attrs[COLOR_nit__model__MSignature___mparameters].val; /* _mparameters on <var_msignature:nullable MSignature(MSignature)> */
2468 if (unlikely(var147 == NULL)) {
2469 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mparameters");
2470 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1756);
2471 fatal_exit(1);
2472 }
2473 var145 = var147;
2474 RET_LABEL146:(void)0;
2475 }
2476 }
2477 {
2478 var148 = standard___standard__Array___standard__abstract_collection__SequenceRead___91d_93d(var145, var_vararg_rank);
2479 }
2480 {
2481 { /* Inline model#MParameter#mtype (var148) on <var148:nullable Object(MParameter)> */
2482 var151 = var148->attrs[COLOR_nit__model__MParameter___mtype].val; /* _mtype on <var148:nullable Object(MParameter)> */
2483 if (unlikely(var151 == NULL)) {
2484 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype");
2485 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1879);
2486 fatal_exit(1);
2487 }
2488 var149 = var151;
2489 RET_LABEL150:(void)0;
2490 }
2491 }
2492 var_elttype = var149;
2493 {
2494 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (self) on <self:RapidTypeAnalysis> */
2495 var154 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
2496 if (unlikely(var154 == NULL)) {
2497 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
2498 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
2499 fatal_exit(1);
2500 }
2501 var152 = var154;
2502 RET_LABEL153:(void)0;
2503 }
2504 }
2505 {
2506 var155 = nit__model___MModule___array_type(var152, var_elttype);
2507 }
2508 var_vararg = var155;
2509 {
2510 nit___nit__RapidTypeVisitor___add_type(var_v, var_vararg); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_type on <var_v:RapidTypeVisitor>*/
2511 }
2512 {
2513 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (self) on <self:RapidTypeAnalysis> */
2514 var158 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
2515 if (unlikely(var158 == NULL)) {
2516 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
2517 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
2518 fatal_exit(1);
2519 }
2520 var156 = var158;
2521 RET_LABEL157:(void)0;
2522 }
2523 }
2524 {
2525 var159 = nit__model___MModule___native_array_type(var156, var_elttype);
2526 }
2527 var_native = var159;
2528 {
2529 nit___nit__RapidTypeVisitor___add_type(var_v, var_native); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_type on <var_v:RapidTypeVisitor>*/
2530 }
2531 {
2532 { /* Inline rapid_type_analysis#RapidTypeAnalysis#modelbuilder (self) on <self:RapidTypeAnalysis> */
2533 var162 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___modelbuilder].val; /* _modelbuilder on <self:RapidTypeAnalysis> */
2534 if (unlikely(var162 == NULL)) {
2535 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder");
2536 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 53);
2537 fatal_exit(1);
2538 }
2539 var160 = var162;
2540 RET_LABEL161:(void)0;
2541 }
2542 }
2543 if (likely(varonce163!=NULL)) {
2544 var164 = varonce163;
2545 } else {
2546 var165 = "with_native";
2547 var166 = standard___standard__NativeString___to_s_with_length(var165, 11l);
2548 var164 = var166;
2549 varonce163 = var164;
2550 }
2551 {
2552 { /* Inline model#MClassType#mclass (var_vararg) on <var_vararg:MClassType> */
2553 var169 = var_vararg->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on <var_vararg:MClassType> */
2554 if (unlikely(var169 == NULL)) {
2555 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
2556 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138);
2557 fatal_exit(1);
2558 }
2559 var167 = var169;
2560 RET_LABEL168:(void)0;
2561 }
2562 }
2563 {
2564 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (self) on <self:RapidTypeAnalysis> */
2565 var172 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
2566 if (unlikely(var172 == NULL)) {
2567 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
2568 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
2569 fatal_exit(1);
2570 }
2571 var170 = var172;
2572 RET_LABEL171:(void)0;
2573 }
2574 }
2575 {
2576 var173 = nit___nit__ModelBuilder___force_get_primitive_method(var160, var_node, var164, var167, var170);
2577 }
2578 {
2579 nit___nit__RapidTypeVisitor___add_monomorphic_send(var_v, var_vararg, var173); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_monomorphic_send on <var_v:RapidTypeVisitor>*/
2580 }
2581 } else {
2582 }
2583 var_sig = var_msignature;
2584 {
2585 { /* Inline model#MProperty#intro (var_mmeth) on <var_mmeth:MMethod> */
2586 var176 = var_mmeth->attrs[COLOR_nit__model__MProperty___intro].val; /* _intro on <var_mmeth:MMethod> */
2587 if (unlikely(var176 == NULL)) {
2588 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro");
2589 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1968);
2590 fatal_exit(1);
2591 }
2592 var174 = var176;
2593 RET_LABEL175:(void)0;
2594 }
2595 }
2596 {
2597 { /* Inline model#MMethodDef#msignature (var174) on <var174:MPropDef(MMethodDef)> */
2598 var179 = var174->attrs[COLOR_nit__model__MMethodDef___msignature].val; /* _msignature on <var174:MPropDef(MMethodDef)> */
2599 var177 = var179;
2600 RET_LABEL178:(void)0;
2601 }
2602 }
2603 if (unlikely(var177 == NULL)) {
2604 PRINT_ERROR("Runtime error: %s", "Cast failed");
2605 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 241);
2606 fatal_exit(1);
2607 }
2608 var_osig = var177;
2609 var_i = 0l;
2610 {
2611 var180 = nit___nit__MSignature___arity(var_sig);
2612 }
2613 var_ = var180;
2614 for(;;) {
2615 {
2616 { /* Inline kernel#Int#< (var_i,var_) on <var_i:Int> */
2617 /* Covariant cast for argument 0 (i) <var_:Int> isa OTHER */
2618 /* <var_:Int> isa OTHER */
2619 var183 = 1; /* easy <var_:Int> isa OTHER*/
2620 if (unlikely(!var183)) {
2621 var_class_name186 = type_standard__Int.name;
2622 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name186);
2623 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 534);
2624 fatal_exit(1);
2625 }
2626 var187 = var_i < var_;
2627 var181 = var187;
2628 goto RET_LABEL182;
2629 RET_LABEL182:(void)0;
2630 }
2631 }
2632 if (var181){
2633 {
2634 { /* Inline model#MSignature#mparameters (var_osig) on <var_osig:MSignature> */
2635 var190 = var_osig->attrs[COLOR_nit__model__MSignature___mparameters].val; /* _mparameters on <var_osig:MSignature> */
2636 if (unlikely(var190 == NULL)) {
2637 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mparameters");
2638 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1756);
2639 fatal_exit(1);
2640 }
2641 var188 = var190;
2642 RET_LABEL189:(void)0;
2643 }
2644 }
2645 {
2646 var191 = standard___standard__Array___standard__abstract_collection__SequenceRead___91d_93d(var188, var_i);
2647 }
2648 {
2649 { /* Inline model#MParameter#mtype (var191) on <var191:nullable Object(MParameter)> */
2650 var194 = var191->attrs[COLOR_nit__model__MParameter___mtype].val; /* _mtype on <var191:nullable Object(MParameter)> */
2651 if (unlikely(var194 == NULL)) {
2652 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype");
2653 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1879);
2654 fatal_exit(1);
2655 }
2656 var192 = var194;
2657 RET_LABEL193:(void)0;
2658 }
2659 }
2660 var_origtype = var192;
2661 {
2662 var195 = ((short int(*)(val* self))(var_origtype->class->vft[COLOR_nit__model__MType__need_anchor]))(var_origtype); /* need_anchor on <var_origtype:MType>*/
2663 }
2664 var196 = !var195;
2665 if (var196){
2666 goto BREAK_label197;
2667 } else {
2668 }
2669 {
2670 { /* Inline model#MSignature#mparameters (var_sig) on <var_sig:MSignature> */
2671 var200 = var_sig->attrs[COLOR_nit__model__MSignature___mparameters].val; /* _mparameters on <var_sig:MSignature> */
2672 if (unlikely(var200 == NULL)) {
2673 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mparameters");
2674 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1756);
2675 fatal_exit(1);
2676 }
2677 var198 = var200;
2678 RET_LABEL199:(void)0;
2679 }
2680 }
2681 {
2682 var201 = standard___standard__Array___standard__abstract_collection__SequenceRead___91d_93d(var198, var_i);
2683 }
2684 {
2685 { /* Inline model#MParameter#mtype (var201) on <var201:nullable Object(MParameter)> */
2686 var204 = var201->attrs[COLOR_nit__model__MParameter___mtype].val; /* _mtype on <var201:nullable Object(MParameter)> */
2687 if (unlikely(var204 == NULL)) {
2688 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype");
2689 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1879);
2690 fatal_exit(1);
2691 }
2692 var202 = var204;
2693 RET_LABEL203:(void)0;
2694 }
2695 }
2696 var_paramtype = var202;
2697 {
2698 nit___nit__RapidTypeAnalysis___add_cast(self, var_paramtype); /* Direct call rapid_type_analysis#RapidTypeAnalysis#add_cast on <self:RapidTypeAnalysis>*/
2699 }
2700 BREAK_label197: (void)0;
2701 {
2702 var205 = standard___standard__Int___Discrete__successor(var_i, 1l);
2703 }
2704 var_i = var205;
2705 } else {
2706 goto BREAK_label206;
2707 }
2708 }
2709 BREAK_label206: (void)0;
2710 {
2711 { /* Inline rapid_type_analysis#RapidTypeAnalysis#modelbuilder (self) on <self:RapidTypeAnalysis> */
2712 var209 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___modelbuilder].val; /* _modelbuilder on <self:RapidTypeAnalysis> */
2713 if (unlikely(var209 == NULL)) {
2714 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder");
2715 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 53);
2716 fatal_exit(1);
2717 }
2718 var207 = var209;
2719 RET_LABEL208:(void)0;
2720 }
2721 }
2722 {
2723 var210 = nit__modelize_property___ModelBuilder___mpropdef2node(var207, var_mmethoddef);
2724 }
2725 var_npropdef = var210;
2726 /* <var_npropdef:nullable ANode> isa AClassdef */
2727 cltype212 = type_nit__AClassdef.color;
2728 idtype213 = type_nit__AClassdef.id;
2729 if(var_npropdef == NULL) {
2730 var211 = 0;
2731 } else {
2732 if(cltype212 >= var_npropdef->type->table_size) {
2733 var211 = 0;
2734 } else {
2735 var211 = var_npropdef->type->type_table[cltype212] == idtype213;
2736 }
2737 }
2738 if (var211){
2739 {
2740 { /* Inline modelize_property#AClassdef#mfree_init (var_npropdef) on <var_npropdef:nullable ANode(AClassdef)> */
2741 var216 = var_npropdef->attrs[COLOR_nit__modelize_property__AClassdef___mfree_init].val; /* _mfree_init on <var_npropdef:nullable ANode(AClassdef)> */
2742 var214 = var216;
2743 RET_LABEL215:(void)0;
2744 }
2745 }
2746 {
2747 { /* Inline kernel#Object#== (var_mmethoddef,var214) on <var_mmethoddef:MMethodDef> */
2748 var_other = var214;
2749 {
2750 { /* Inline kernel#Object#is_same_instance (var_mmethoddef,var_other) on <var_mmethoddef:MMethodDef> */
2751 var221 = var_mmethoddef == var_other;
2752 var219 = var221;
2753 goto RET_LABEL220;
2754 RET_LABEL220:(void)0;
2755 }
2756 }
2757 var217 = var219;
2758 goto RET_LABEL218;
2759 RET_LABEL218:(void)0;
2760 }
2761 }
2762 if (unlikely(!var217)) {
2763 PRINT_ERROR("Runtime error: %s", "Assert failed");
2764 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 253);
2765 fatal_exit(1);
2766 }
2767 {
2768 { /* Inline model#MPropDef#mproperty (var_mmethoddef) on <var_mmethoddef:MMethodDef> */
2769 var225 = var_mmethoddef->attrs[COLOR_nit__model__MPropDef___mproperty].val; /* _mproperty on <var_mmethoddef:MMethodDef> */
2770 if (unlikely(var225 == NULL)) {
2771 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mproperty");
2772 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2212);
2773 fatal_exit(1);
2774 }
2775 var223 = var225;
2776 RET_LABEL224:(void)0;
2777 }
2778 }
2779 {
2780 { /* Inline model#MMethod#is_root_init (var223) on <var223:MProperty(MMethod)> */
2781 var228 = var223->attrs[COLOR_nit__model__MMethod___is_root_init].s; /* _is_root_init on <var223:MProperty(MMethod)> */
2782 var226 = var228;
2783 RET_LABEL227:(void)0;
2784 }
2785 }
2786 var_229 = var226;
2787 if (var226){
2788 {
2789 var230 = nit___nit__MPropDef___is_intro(var_mmethoddef);
2790 }
2791 var231 = !var230;
2792 var222 = var231;
2793 } else {
2794 var222 = var_229;
2795 }
2796 if (var222){
2797 {
2798 { /* Inline rapid_type_analysis#RapidTypeVisitor#receiver (var_v) on <var_v:RapidTypeVisitor> */
2799 var234 = var_v->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___receiver].val; /* _receiver on <var_v:RapidTypeVisitor> */
2800 if (unlikely(var234 == NULL)) {
2801 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _receiver");
2802 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 448);
2803 fatal_exit(1);
2804 }
2805 var232 = var234;
2806 RET_LABEL233:(void)0;
2807 }
2808 }
2809 {
2810 nit___nit__RapidTypeAnalysis___add_super_send(self, var232, var_mmethoddef); /* Direct call rapid_type_analysis#RapidTypeAnalysis#add_super_send on <self:RapidTypeAnalysis>*/
2811 }
2812 } else {
2813 }
2814 goto BREAK_label;
2815 } else {
2816 {
2817 { /* Inline model#MMethodDef#constant_value (var_mmethoddef) on <var_mmethoddef:MMethodDef> */
2818 var237 = var_mmethoddef->attrs[COLOR_nit__model__MMethodDef___constant_value].val; /* _constant_value on <var_mmethoddef:MMethodDef> */
2819 var235 = var237;
2820 RET_LABEL236:(void)0;
2821 }
2822 }
2823 if (var235 == NULL) {
2824 var238 = 0; /* is null */
2825 } else {
2826 var238 = 1; /* arg is null and recv is not */
2827 }
2828 if (0) {
2829 var239 = ((short int(*)(val* self, val* p0))((((long)var235&3)?class_info[((long)var235&3)]:var235->class)->vft[COLOR_standard__kernel__Object___33d_61d]))(var235, ((val*)NULL)); /* != on <var235:nullable Object>*/
2830 var238 = var239;
2831 }
2832 if (var238){
2833 {
2834 { /* Inline model#MSignature#return_mtype (var_msignature) on <var_msignature:nullable MSignature(MSignature)> */
2835 var242 = var_msignature->attrs[COLOR_nit__model__MSignature___return_mtype].val; /* _return_mtype on <var_msignature:nullable MSignature(MSignature)> */
2836 var240 = var242;
2837 RET_LABEL241:(void)0;
2838 }
2839 }
2840 /* <var240:nullable MType> isa MClassType */
2841 cltype244 = type_nit__MClassType.color;
2842 idtype245 = type_nit__MClassType.id;
2843 if(var240 == NULL) {
2844 var243 = 0;
2845 } else {
2846 if(cltype244 >= var240->type->table_size) {
2847 var243 = 0;
2848 } else {
2849 var243 = var240->type->type_table[cltype244] == idtype245;
2850 }
2851 }
2852 if (unlikely(!var243)) {
2853 var_class_name246 = var240 == NULL ? "null" : var240->type->name;
2854 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name246);
2855 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 261);
2856 fatal_exit(1);
2857 }
2858 {
2859 nit___nit__RapidTypeVisitor___add_type(var_v, var240); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_type on <var_v:RapidTypeVisitor>*/
2860 }
2861 goto BREAK_label;
2862 } else {
2863 if (var_npropdef == NULL) {
2864 var247 = 1; /* is null */
2865 } else {
2866 var247 = 0; /* arg is null but recv is not */
2867 }
2868 if (0) {
2869 { /* Inline kernel#Object#== (var_npropdef,((val*)NULL)) on <var_npropdef:nullable ANode> */
2870 var_other = ((val*)NULL);
2871 {
2872 { /* Inline kernel#Object#is_same_instance (var_npropdef,var_other) on <var_npropdef:nullable ANode(ANode)> */
2873 var252 = var_npropdef == var_other;
2874 var250 = var252;
2875 goto RET_LABEL251;
2876 RET_LABEL251:(void)0;
2877 }
2878 }
2879 var248 = var250;
2880 goto RET_LABEL249;
2881 RET_LABEL249:(void)0;
2882 }
2883 var247 = var248;
2884 }
2885 if (var247){
2886 PRINT_ERROR("Runtime error: %s", "Aborted");
2887 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 264);
2888 fatal_exit(1);
2889 } else {
2890 }
2891 }
2892 }
2893 /* <var_npropdef:nullable ANode(ANode)> isa AMethPropdef */
2894 cltype254 = type_nit__AMethPropdef.color;
2895 idtype255 = type_nit__AMethPropdef.id;
2896 if(cltype254 >= var_npropdef->type->table_size) {
2897 var253 = 0;
2898 } else {
2899 var253 = var_npropdef->type->type_table[cltype254] == idtype255;
2900 }
2901 if (var253){
2902 {
2903 { /* Inline auto_super_init#AMethPropdef#auto_super_inits (var_npropdef) on <var_npropdef:nullable ANode(AMethPropdef)> */
2904 var258 = var_npropdef->attrs[COLOR_nit__auto_super_init__AMethPropdef___auto_super_inits].val; /* _auto_super_inits on <var_npropdef:nullable ANode(AMethPropdef)> */
2905 var256 = var258;
2906 RET_LABEL257:(void)0;
2907 }
2908 }
2909 var_auto_super_inits = var256;
2910 if (var_auto_super_inits == NULL) {
2911 var259 = 0; /* is null */
2912 } else {
2913 var259 = 1; /* arg is null and recv is not */
2914 }
2915 if (0) {
2916 { /* Inline kernel#Object#!= (var_auto_super_inits,((val*)NULL)) on <var_auto_super_inits:nullable Array[CallSite]> */
2917 var_other23 = ((val*)NULL);
2918 {
2919 var262 = ((short int(*)(val* self, val* p0))(var_auto_super_inits->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_auto_super_inits, var_other23); /* == on <var_auto_super_inits:nullable Array[CallSite](Array[CallSite])>*/
2920 }
2921 var263 = !var262;
2922 var260 = var263;
2923 goto RET_LABEL261;
2924 RET_LABEL261:(void)0;
2925 }
2926 var259 = var260;
2927 }
2928 if (var259){
2929 var_264 = var_auto_super_inits;
2930 {
2931 var265 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_264);
2932 }
2933 var_266 = var265;
2934 for(;;) {
2935 {
2936 var267 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_266);
2937 }
2938 if (var267){
2939 {
2940 var268 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_266);
2941 }
2942 var_auto_super_init = var268;
2943 {
2944 nit___nit__RapidTypeVisitor___add_callsite(var_v, var_auto_super_init); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_callsite on <var_v:RapidTypeVisitor>*/
2945 }
2946 {
2947 standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_266); /* Direct call array#ArrayIterator#next on <var_266:ArrayIterator[CallSite]>*/
2948 }
2949 } else {
2950 goto BREAK_label269;
2951 }
2952 }
2953 BREAK_label269: (void)0;
2954 {
2955 standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__finish(var_266); /* Direct call array#ArrayIterator#finish on <var_266:ArrayIterator[CallSite]>*/
2956 }
2957 } else {
2958 }
2959 {
2960 { /* Inline auto_super_init#AMethPropdef#auto_super_call (var_npropdef) on <var_npropdef:nullable ANode(AMethPropdef)> */
2961 var272 = var_npropdef->attrs[COLOR_nit__auto_super_init__AMethPropdef___auto_super_call].s; /* _auto_super_call on <var_npropdef:nullable ANode(AMethPropdef)> */
2962 var270 = var272;
2963 RET_LABEL271:(void)0;
2964 }
2965 }
2966 if (var270){
2967 {
2968 { /* Inline rapid_type_analysis#RapidTypeVisitor#receiver (var_v) on <var_v:RapidTypeVisitor> */
2969 var275 = var_v->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___receiver].val; /* _receiver on <var_v:RapidTypeVisitor> */
2970 if (unlikely(var275 == NULL)) {
2971 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _receiver");
2972 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 448);
2973 fatal_exit(1);
2974 }
2975 var273 = var275;
2976 RET_LABEL274:(void)0;
2977 }
2978 }
2979 {
2980 nit___nit__RapidTypeAnalysis___add_super_send(self, var273, var_mmethoddef); /* Direct call rapid_type_analysis#RapidTypeAnalysis#add_super_send on <self:RapidTypeAnalysis>*/
2981 }
2982 } else {
2983 }
2984 } else {
2985 }
2986 {
2987 { /* Inline model#MMethodDef#is_intern (var_mmethoddef) on <var_mmethoddef:MMethodDef> */
2988 var279 = var_mmethoddef->attrs[COLOR_nit__model__MMethodDef___is_intern].s; /* _is_intern on <var_mmethoddef:MMethodDef> */
2989 var277 = var279;
2990 RET_LABEL278:(void)0;
2991 }
2992 }
2993 var_280 = var277;
2994 if (var277){
2995 var276 = var_280;
2996 } else {
2997 {
2998 { /* Inline model#MMethodDef#is_extern (var_mmethoddef) on <var_mmethoddef:MMethodDef> */
2999 var283 = var_mmethoddef->attrs[COLOR_nit__model__MMethodDef___is_extern].s; /* _is_extern on <var_mmethoddef:MMethodDef> */
3000 var281 = var283;
3001 RET_LABEL282:(void)0;
3002 }
3003 }
3004 var276 = var281;
3005 }
3006 if (var276){
3007 {
3008 { /* Inline model#MSignature#return_mtype (var_msignature) on <var_msignature:nullable MSignature(MSignature)> */
3009 var286 = var_msignature->attrs[COLOR_nit__model__MSignature___return_mtype].val; /* _return_mtype on <var_msignature:nullable MSignature(MSignature)> */
3010 var284 = var286;
3011 RET_LABEL285:(void)0;
3012 }
3013 }
3014 var_ret = var284;
3015 if (var_ret == NULL) {
3016 var290 = 0; /* is null */
3017 } else {
3018 var290 = 1; /* arg is null and recv is not */
3019 }
3020 if (0) {
3021 { /* Inline kernel#Object#!= (var_ret,((val*)NULL)) on <var_ret:nullable MType> */
3022 var_other23 = ((val*)NULL);
3023 {
3024 var293 = ((short int(*)(val* self, val* p0))(var_ret->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_ret, var_other23); /* == on <var_ret:nullable MType(MType)>*/
3025 }
3026 var294 = !var293;
3027 var291 = var294;
3028 goto RET_LABEL292;
3029 RET_LABEL292:(void)0;
3030 }
3031 var290 = var291;
3032 }
3033 var_295 = var290;
3034 if (var290){
3035 /* <var_ret:nullable MType(MType)> isa MClassType */
3036 cltype297 = type_nit__MClassType.color;
3037 idtype298 = type_nit__MClassType.id;
3038 if(cltype297 >= var_ret->type->table_size) {
3039 var296 = 0;
3040 } else {
3041 var296 = var_ret->type->type_table[cltype297] == idtype298;
3042 }
3043 var289 = var296;
3044 } else {
3045 var289 = var_295;
3046 }
3047 var_299 = var289;
3048 if (var289){
3049 {
3050 { /* Inline model#MClassType#mclass (var_ret) on <var_ret:nullable MType(MClassType)> */
3051 var302 = var_ret->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on <var_ret:nullable MType(MClassType)> */
3052 if (unlikely(var302 == NULL)) {
3053 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
3054 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138);
3055 fatal_exit(1);
3056 }
3057 var300 = var302;
3058 RET_LABEL301:(void)0;
3059 }
3060 }
3061 {
3062 { /* Inline model#MClass#kind (var300) on <var300:MClass> */
3063 var305 = var300->attrs[COLOR_nit__model__MClass___kind].val; /* _kind on <var300:MClass> */
3064 if (unlikely(var305 == NULL)) {
3065 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _kind");
3066 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 436);
3067 fatal_exit(1);
3068 }
3069 var303 = var305;
3070 RET_LABEL304:(void)0;
3071 }
3072 }
3073 var306 = glob_sys;
3074 {
3075 var307 = nit__model___standard__Sys___abstract_kind(var306);
3076 }
3077 {
3078 { /* Inline kernel#Object#!= (var303,var307) on <var303:MClassKind> */
3079 var_other23 = var307;
3080 {
3081 var310 = ((short int(*)(val* self, val* p0))(var303->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var303, var_other23); /* == on <var303:MClassKind>*/
3082 }
3083 var311 = !var310;
3084 var308 = var311;
3085 goto RET_LABEL309;
3086 RET_LABEL309:(void)0;
3087 }
3088 }
3089 var288 = var308;
3090 } else {
3091 var288 = var_299;
3092 }
3093 var_312 = var288;
3094 if (var288){
3095 {
3096 { /* Inline model#MClassType#mclass (var_ret) on <var_ret:nullable MType(MClassType)> */
3097 var315 = var_ret->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on <var_ret:nullable MType(MClassType)> */
3098 if (unlikely(var315 == NULL)) {
3099 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
3100 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138);
3101 fatal_exit(1);
3102 }
3103 var313 = var315;
3104 RET_LABEL314:(void)0;
3105 }
3106 }
3107 {
3108 { /* Inline model#MClass#kind (var313) on <var313:MClass> */
3109 var318 = var313->attrs[COLOR_nit__model__MClass___kind].val; /* _kind on <var313:MClass> */
3110 if (unlikely(var318 == NULL)) {
3111 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _kind");
3112 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 436);
3113 fatal_exit(1);
3114 }
3115 var316 = var318;
3116 RET_LABEL317:(void)0;
3117 }
3118 }
3119 var319 = glob_sys;
3120 {
3121 var320 = nit__model___standard__Sys___interface_kind(var319);
3122 }
3123 {
3124 { /* Inline kernel#Object#!= (var316,var320) on <var316:MClassKind> */
3125 var_other23 = var320;
3126 {
3127 var323 = ((short int(*)(val* self, val* p0))(var316->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var316, var_other23); /* == on <var316:MClassKind>*/
3128 }
3129 var324 = !var323;
3130 var321 = var324;
3131 goto RET_LABEL322;
3132 RET_LABEL322:(void)0;
3133 }
3134 }
3135 var287 = var321;
3136 } else {
3137 var287 = var_312;
3138 }
3139 if (var287){
3140 {
3141 nit___nit__RapidTypeVisitor___add_type(var_v, var_ret); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_type on <var_v:RapidTypeVisitor>*/
3142 }
3143 } else {
3144 }
3145 } else {
3146 }
3147 {
3148 nit___nit__Visitor___enter_visit(var_v, var_npropdef); /* Direct call parser_nodes#Visitor#enter_visit on <var_v:RapidTypeVisitor>*/
3149 }
3150 } else {
3151 goto BREAK_label325;
3152 }
3153 BREAK_label: (void)0;
3154 }
3155 BREAK_label325: (void)0;
3156 var326 = NEW_standard__List(&type_standard__List__nit__MClassType);
3157 {
3158 { /* Inline list#List#init (var326) on <var326:List[MClassType]> */
3159 RET_LABEL327:(void)0;
3160 }
3161 }
3162 var_todo_types = var326;
3163 {
3164 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_types (self) on <self:RapidTypeAnalysis> */
3165 var330 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on <self:RapidTypeAnalysis> */
3166 if (unlikely(var330 == NULL)) {
3167 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types");
3168 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 60);
3169 fatal_exit(1);
3170 }
3171 var328 = var330;
3172 RET_LABEL329:(void)0;
3173 }
3174 }
3175 {
3176 standard___standard__SimpleCollection___add_all(var_todo_types, var328); /* Direct call abstract_collection#SimpleCollection#add_all on <var_todo_types:List[MClassType]>*/
3177 }
3178 for(;;) {
3179 {
3180 var331 = standard___standard__List___standard__abstract_collection__Collection__is_empty(var_todo_types);
3181 }
3182 var332 = !var331;
3183 if (var332){
3184 {
3185 var333 = standard___standard__List___standard__abstract_collection__Sequence__shift(var_todo_types);
3186 }
3187 var_t = var333;
3188 {
3189 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_open_types (self) on <self:RapidTypeAnalysis> */
3190 var336 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_open_types].val; /* _live_open_types on <self:RapidTypeAnalysis> */
3191 if (unlikely(var336 == NULL)) {
3192 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_open_types");
3193 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 65);
3194 fatal_exit(1);
3195 }
3196 var334 = var336;
3197 RET_LABEL335:(void)0;
3198 }
3199 }
3200 var_337 = var334;
3201 {
3202 var338 = standard___standard__HashSet___standard__abstract_collection__Collection__iterator(var_337);
3203 }
3204 var_339 = var338;
3205 for(;;) {
3206 {
3207 var340 = ((short int(*)(val* self))((((long)var_339&3)?class_info[((long)var_339&3)]:var_339->class)->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_339); /* is_ok on <var_339:Iterator[MClassType]>*/
3208 }
3209 if (var340){
3210 {
3211 var341 = ((val*(*)(val* self))((((long)var_339&3)?class_info[((long)var_339&3)]:var_339->class)->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_339); /* item on <var_339:Iterator[MClassType]>*/
3212 }
3213 var_ot = var341;
3214 {
3215 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (self) on <self:RapidTypeAnalysis> */
3216 var344 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
3217 if (unlikely(var344 == NULL)) {
3218 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
3219 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
3220 fatal_exit(1);
3221 }
3222 var342 = var344;
3223 RET_LABEL343:(void)0;
3224 }
3225 }
3226 {
3227 var345 = ((short int(*)(val* self, val* p0, val* p1, val* p2))(var_ot->class->vft[COLOR_nit__model__MType__can_resolve_for]))(var_ot, var_t, var_t, var342); /* can_resolve_for on <var_ot:MClassType>*/
3228 }
3229 var346 = !var345;
3230 if (var346){
3231 goto BREAK_label347;
3232 } else {
3233 }
3234 {
3235 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (self) on <self:RapidTypeAnalysis> */
3236 var350 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
3237 if (unlikely(var350 == NULL)) {
3238 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
3239 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
3240 fatal_exit(1);
3241 }
3242 var348 = var350;
3243 RET_LABEL349:(void)0;
3244 }
3245 }
3246 {
3247 var351 = nit___nit__MClassType___MType__anchor_to(var_ot, var348, var_t);
3248 }
3249 var_rt = var351;
3250 {
3251 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_types (self) on <self:RapidTypeAnalysis> */
3252 var354 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on <self:RapidTypeAnalysis> */
3253 if (unlikely(var354 == NULL)) {
3254 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types");
3255 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 60);
3256 fatal_exit(1);
3257 }
3258 var352 = var354;
3259 RET_LABEL353:(void)0;
3260 }
3261 }
3262 {
3263 var355 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var352, var_rt);
3264 }
3265 if (var355){
3266 goto BREAK_label347;
3267 } else {
3268 }
3269 {
3270 var356 = nit___nit__RapidTypeAnalysis___check_depth(self, var_rt);
3271 }
3272 var357 = !var356;
3273 if (var357){
3274 goto BREAK_label347;
3275 } else {
3276 }
3277 {
3278 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_types (self) on <self:RapidTypeAnalysis> */
3279 var360 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on <self:RapidTypeAnalysis> */
3280 if (unlikely(var360 == NULL)) {
3281 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types");
3282 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 60);
3283 fatal_exit(1);
3284 }
3285 var358 = var360;
3286 RET_LABEL359:(void)0;
3287 }
3288 }
3289 {
3290 standard___standard__HashSet___standard__abstract_collection__SimpleCollection__add(var358, var_rt); /* Direct call hash_collection#HashSet#add on <var358:HashSet[MClassType]>*/
3291 }
3292 {
3293 standard___standard__Sequence___SimpleCollection__add(var_todo_types, var_rt); /* Direct call abstract_collection#Sequence#add on <var_todo_types:List[MClassType]>*/
3294 }
3295 BREAK_label347: (void)0;
3296 {
3297 ((void(*)(val* self))((((long)var_339&3)?class_info[((long)var_339&3)]:var_339->class)->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_339); /* next on <var_339:Iterator[MClassType]>*/
3298 }
3299 } else {
3300 goto BREAK_label361;
3301 }
3302 }
3303 BREAK_label361: (void)0;
3304 {
3305 ((void(*)(val* self))((((long)var_339&3)?class_info[((long)var_339&3)]:var_339->class)->vft[COLOR_standard__abstract_collection__Iterator__finish]))(var_339); /* finish on <var_339:Iterator[MClassType]>*/
3306 }
3307 } else {
3308 goto BREAK_label362;
3309 }
3310 }
3311 BREAK_label362: (void)0;
3312 {
3313 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_open_cast_types (self) on <self:RapidTypeAnalysis> */
3314 var365 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_open_cast_types].val; /* _live_open_cast_types on <self:RapidTypeAnalysis> */
3315 if (unlikely(var365 == NULL)) {
3316 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_open_cast_types");
3317 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 75);
3318 fatal_exit(1);
3319 }
3320 var363 = var365;
3321 RET_LABEL364:(void)0;
3322 }
3323 }
3324 var_366 = var363;
3325 {
3326 var367 = standard___standard__HashSet___standard__abstract_collection__Collection__iterator(var_366);
3327 }
3328 var_368 = var367;
3329 for(;;) {
3330 {
3331 var369 = ((short int(*)(val* self))((((long)var_368&3)?class_info[((long)var_368&3)]:var_368->class)->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_368); /* is_ok on <var_368:Iterator[MType]>*/
3332 }
3333 if (var369){
3334 {
3335 var370 = ((val*(*)(val* self))((((long)var_368&3)?class_info[((long)var_368&3)]:var_368->class)->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_368); /* item on <var_368:Iterator[MType]>*/
3336 }
3337 var_ot371 = var370;
3338 {
3339 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_types (self) on <self:RapidTypeAnalysis> */
3340 var374 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on <self:RapidTypeAnalysis> */
3341 if (unlikely(var374 == NULL)) {
3342 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types");
3343 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 60);
3344 fatal_exit(1);
3345 }
3346 var372 = var374;
3347 RET_LABEL373:(void)0;
3348 }
3349 }
3350 var_375 = var372;
3351 {
3352 var376 = standard___standard__HashSet___standard__abstract_collection__Collection__iterator(var_375);
3353 }
3354 var_377 = var376;
3355 for(;;) {
3356 {
3357 var378 = ((short int(*)(val* self))((((long)var_377&3)?class_info[((long)var_377&3)]:var_377->class)->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_377); /* is_ok on <var_377:Iterator[MClassType]>*/
3358 }
3359 if (var378){
3360 {
3361 var379 = ((val*(*)(val* self))((((long)var_377&3)?class_info[((long)var_377&3)]:var_377->class)->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_377); /* item on <var_377:Iterator[MClassType]>*/
3362 }
3363 var_t380 = var379;
3364 {
3365 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (self) on <self:RapidTypeAnalysis> */
3366 var383 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
3367 if (unlikely(var383 == NULL)) {
3368 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
3369 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
3370 fatal_exit(1);
3371 }
3372 var381 = var383;
3373 RET_LABEL382:(void)0;
3374 }
3375 }
3376 {
3377 var384 = ((short int(*)(val* self, val* p0, val* p1, val* p2))(var_ot371->class->vft[COLOR_nit__model__MType__can_resolve_for]))(var_ot371, var_t380, var_t380, var381); /* can_resolve_for on <var_ot371:MType>*/
3378 }
3379 var385 = !var384;
3380 if (var385){
3381 goto BREAK_label386;
3382 } else {
3383 }
3384 {
3385 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (self) on <self:RapidTypeAnalysis> */
3386 var389 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
3387 if (unlikely(var389 == NULL)) {
3388 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
3389 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
3390 fatal_exit(1);
3391 }
3392 var387 = var389;
3393 RET_LABEL388:(void)0;
3394 }
3395 }
3396 {
3397 var390 = ((val*(*)(val* self, val* p0, val* p1))(var_ot371->class->vft[COLOR_nit__model__MType__anchor_to]))(var_ot371, var387, var_t380); /* anchor_to on <var_ot371:MType>*/
3398 }
3399 var_rt391 = var390;
3400 {
3401 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_cast_types (self) on <self:RapidTypeAnalysis> */
3402 var394 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_cast_types].val; /* _live_cast_types on <self:RapidTypeAnalysis> */
3403 if (unlikely(var394 == NULL)) {
3404 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_cast_types");
3405 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 72);
3406 fatal_exit(1);
3407 }
3408 var392 = var394;
3409 RET_LABEL393:(void)0;
3410 }
3411 }
3412 {
3413 standard___standard__HashSet___standard__abstract_collection__SimpleCollection__add(var392, var_rt391); /* Direct call hash_collection#HashSet#add on <var392:HashSet[MType]>*/
3414 }
3415 BREAK_label386: (void)0;
3416 {
3417 ((void(*)(val* self))((((long)var_377&3)?class_info[((long)var_377&3)]:var_377->class)->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_377); /* next on <var_377:Iterator[MClassType]>*/
3418 }
3419 } else {
3420 goto BREAK_label395;
3421 }
3422 }
3423 BREAK_label395: (void)0;
3424 {
3425 ((void(*)(val* self))((((long)var_377&3)?class_info[((long)var_377&3)]:var_377->class)->vft[COLOR_standard__abstract_collection__Iterator__finish]))(var_377); /* finish on <var_377:Iterator[MClassType]>*/
3426 }
3427 {
3428 ((void(*)(val* self))((((long)var_368&3)?class_info[((long)var_368&3)]:var_368->class)->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_368); /* next on <var_368:Iterator[MType]>*/
3429 }
3430 } else {
3431 goto BREAK_label396;
3432 }
3433 }
3434 BREAK_label396: (void)0;
3435 {
3436 ((void(*)(val* self))((((long)var_368&3)?class_info[((long)var_368&3)]:var_368->class)->vft[COLOR_standard__abstract_collection__Iterator__finish]))(var_368); /* finish on <var_368:Iterator[MType]>*/
3437 }
3438 RET_LABEL:;
3439 }
3440 /* method rapid_type_analysis#RapidTypeAnalysis#check_depth for (self: RapidTypeAnalysis, MClassType): Bool */
3441 short int nit___nit__RapidTypeAnalysis___check_depth(val* self, val* p0) {
3442 short int var /* : Bool */;
3443 val* var_mtype /* var mtype: MClassType */;
3444 long var1 /* : Int */;
3445 long var_d /* var d: Int */;
3446 short int var2 /* : Bool */;
3447 short int var4 /* : Bool */;
3448 int cltype;
3449 int idtype;
3450 const char* var_class_name;
3451 short int var5 /* : Bool */;
3452 val* var6 /* : ModelBuilder */;
3453 val* var8 /* : ModelBuilder */;
3454 val* var9 /* : ToolContext */;
3455 val* var11 /* : ToolContext */;
3456 val* var12 /* : NativeArray[String] */;
3457 static val* varonce;
3458 static val* varonce13;
3459 val* var14 /* : String */;
3460 char* var15 /* : NativeString */;
3461 val* var16 /* : FlatString */;
3462 static val* varonce17;
3463 val* var18 /* : String */;
3464 char* var19 /* : NativeString */;
3465 val* var20 /* : FlatString */;
3466 static val* varonce21;
3467 val* var22 /* : String */;
3468 char* var23 /* : NativeString */;
3469 val* var24 /* : FlatString */;
3470 val* var25 /* : String */;
3471 val* var26 /* : String */;
3472 val* var27 /* : String */;
3473 var_mtype = p0;
3474 {
3475 var1 = ((long(*)(val* self))(var_mtype->class->vft[COLOR_nit__model__MType__length]))(var_mtype); /* length on <var_mtype:MClassType>*/
3476 }
3477 var_d = var1;
3478 {
3479 { /* Inline kernel#Int#> (var_d,255l) on <var_d:Int> */
3480 /* Covariant cast for argument 0 (i) <255l:Int> isa OTHER */
3481 /* <255l:Int> isa OTHER */
3482 var4 = 1; /* easy <255l:Int> isa OTHER*/
3483 if (unlikely(!var4)) {
3484 var_class_name = type_standard__Int.name;
3485 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
3486 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 536);
3487 fatal_exit(1);
3488 }
3489 var5 = var_d > 255l;
3490 var2 = var5;
3491 goto RET_LABEL3;
3492 RET_LABEL3:(void)0;
3493 }
3494 }
3495 if (var2){
3496 {
3497 { /* Inline rapid_type_analysis#RapidTypeAnalysis#modelbuilder (self) on <self:RapidTypeAnalysis> */
3498 var8 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___modelbuilder].val; /* _modelbuilder on <self:RapidTypeAnalysis> */
3499 if (unlikely(var8 == NULL)) {
3500 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder");
3501 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 53);
3502 fatal_exit(1);
3503 }
3504 var6 = var8;
3505 RET_LABEL7:(void)0;
3506 }
3507 }
3508 {
3509 { /* Inline modelbuilder_base#ModelBuilder#toolcontext (var6) on <var6:ModelBuilder> */
3510 var11 = var6->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on <var6:ModelBuilder> */
3511 if (unlikely(var11 == NULL)) {
3512 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext");
3513 PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47);
3514 fatal_exit(1);
3515 }
3516 var9 = var11;
3517 RET_LABEL10:(void)0;
3518 }
3519 }
3520 if (unlikely(varonce==NULL)) {
3521 var12 = NEW_standard__NativeArray(5l, &type_standard__NativeArray__standard__String);
3522 if (likely(varonce13!=NULL)) {
3523 var14 = varonce13;
3524 } else {
3525 var15 = "Fatal Error: limitation in the rapidtype analysis engine: a type depth of ";
3526 var16 = standard___standard__NativeString___to_s_with_length(var15, 74l);
3527 var14 = var16;
3528 varonce13 = var14;
3529 }
3530 ((struct instance_standard__NativeArray*)var12)->values[0]=var14;
3531 if (likely(varonce17!=NULL)) {
3532 var18 = varonce17;
3533 } else {
3534 var19 = " is too important, the problematic type is `";
3535 var20 = standard___standard__NativeString___to_s_with_length(var19, 44l);
3536 var18 = var20;
3537 varonce17 = var18;
3538 }
3539 ((struct instance_standard__NativeArray*)var12)->values[2]=var18;
3540 if (likely(varonce21!=NULL)) {
3541 var22 = varonce21;
3542 } else {
3543 var23 = "`.";
3544 var24 = standard___standard__NativeString___to_s_with_length(var23, 2l);
3545 var22 = var24;
3546 varonce21 = var22;
3547 }
3548 ((struct instance_standard__NativeArray*)var12)->values[4]=var22;
3549 } else {
3550 var12 = varonce;
3551 varonce = NULL;
3552 }
3553 var25 = standard__string___Int___Object__to_s(var_d);
3554 ((struct instance_standard__NativeArray*)var12)->values[1]=var25;
3555 {
3556 var26 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_standard__string__Object__to_s]))(var_mtype); /* to_s on <var_mtype:MClassType>*/
3557 }
3558 ((struct instance_standard__NativeArray*)var12)->values[3]=var26;
3559 {
3560 var27 = ((val*(*)(val* self))(var12->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var12); /* native_to_s on <var12:NativeArray[String]>*/
3561 }
3562 varonce = var12;
3563 {
3564 nit___nit__ToolContext___fatal_error(var9, ((val*)NULL), var27); /* Direct call toolcontext#ToolContext#fatal_error on <var9:ToolContext>*/
3565 }
3566 var = 0;
3567 goto RET_LABEL;
3568 } else {
3569 }
3570 var = 1;
3571 goto RET_LABEL;
3572 RET_LABEL:;
3573 return var;
3574 }
3575 /* method rapid_type_analysis#RapidTypeAnalysis#add_new for (self: RapidTypeAnalysis, MClassType, MClassType) */
3576 void nit___nit__RapidTypeAnalysis___add_new(val* self, val* p0, val* p1) {
3577 val* var_recv /* var recv: MClassType */;
3578 val* var_mtype /* var mtype: MClassType */;
3579 short int var /* : Bool */;
3580 short int var1 /* : Bool */;
3581 short int var2 /* : Bool */;
3582 val* var3 /* : HashSet[MClassType] */;
3583 val* var5 /* : HashSet[MClassType] */;
3584 short int var6 /* : Bool */;
3585 val* var7 /* : HashSet[MClassType] */;
3586 val* var9 /* : HashSet[MClassType] */;
3587 val* var10 /* : HashSet[MClassType] */;
3588 val* var12 /* : HashSet[MClassType] */;
3589 short int var13 /* : Bool */;
3590 val* var14 /* : HashSet[MClassType] */;
3591 val* var16 /* : HashSet[MClassType] */;
3592 val* var17 /* : MClass */;
3593 val* var19 /* : MClass */;
3594 val* var_mclass /* var mclass: MClass */;
3595 val* var20 /* : HashSet[MClass] */;
3596 val* var22 /* : HashSet[MClass] */;
3597 short int var23 /* : Bool */;
3598 val* var24 /* : HashSet[MClass] */;
3599 val* var26 /* : HashSet[MClass] */;
3600 val* var27 /* : HashSet[MMethod] */;
3601 val* var29 /* : HashSet[MMethod] */;
3602 val* var_ /* var : HashSet[MMethod] */;
3603 val* var30 /* : Iterator[nullable Object] */;
3604 val* var_31 /* var : Iterator[MMethod] */;
3605 short int var32 /* : Bool */;
3606 val* var33 /* : nullable Object */;
3607 val* var_p /* var p: MMethod */;
3608 val* var34 /* : HashSet[MMethodDef] */;
3609 val* var36 /* : HashSet[MMethodDef] */;
3610 val* var_37 /* var : HashSet[MMethodDef] */;
3611 val* var38 /* : Iterator[nullable Object] */;
3612 val* var_39 /* var : Iterator[MMethodDef] */;
3613 short int var40 /* : Bool */;
3614 val* var41 /* : nullable Object */;
3615 val* var_p42 /* var p: MMethodDef */;
3616 val* var44 /* : Array[MMethod] */;
3617 val* var46 /* : Array[MMethod] */;
3618 val* var_47 /* var : Array[MMethod] */;
3619 val* var48 /* : ArrayIterator[nullable Object] */;
3620 val* var_49 /* var : ArrayIterator[MMethod] */;
3621 short int var50 /* : Bool */;
3622 val* var51 /* : nullable Object */;
3623 val* var_p52 /* var p: MMethod */;
3624 val* var53 /* : HashSet[MMethod] */;
3625 val* var55 /* : HashSet[MMethod] */;
3626 val* var57 /* : Array[MMethod] */;
3627 val* var59 /* : Array[MMethod] */;
3628 val* var60 /* : MModule */;
3629 val* var62 /* : MModule */;
3630 val* var63 /* : MClassType */;
3631 val* var_bound_mtype /* var bound_mtype: MClassType */;
3632 val* var64 /* : MModule */;
3633 val* var66 /* : MModule */;
3634 val* var67 /* : Set[MClassDef] */;
3635 val* var_68 /* var : Set[MClassDef] */;
3636 val* var69 /* : Iterator[nullable Object] */;
3637 val* var_70 /* var : Iterator[MClassDef] */;
3638 short int var71 /* : Bool */;
3639 val* var72 /* : nullable Object */;
3640 val* var_cd /* var cd: MClassDef */;
3641 val* var73 /* : ModelBuilder */;
3642 val* var75 /* : ModelBuilder */;
3643 val* var76 /* : Array[AAttrPropdef] */;
3644 val* var_77 /* var : Array[AAttrPropdef] */;
3645 val* var78 /* : ArrayIterator[nullable Object] */;
3646 val* var_79 /* var : ArrayIterator[AAttrPropdef] */;
3647 short int var80 /* : Bool */;
3648 val* var81 /* : nullable Object */;
3649 val* var_npropdef /* var npropdef: AAttrPropdef */;
3650 short int var82 /* : Bool */;
3651 short int var84 /* : Bool */;
3652 short int var85 /* : Bool */;
3653 val* var87 /* : nullable MMethodDef */;
3654 val* var89 /* : nullable MMethodDef */;
3655 val* var_mpropdef /* var mpropdef: MMethodDef */;
3656 val* var90 /* : RapidTypeVisitor */;
3657 val* var_v /* var v: RapidTypeVisitor */;
3658 val* var91 /* : nullable AExpr */;
3659 val* var93 /* : nullable AExpr */;
3660 val* var94 /* : nullable AExpr */;
3661 val* var96 /* : nullable AExpr */;
3662 var_recv = p0;
3663 var_mtype = p1;
3664 {
3665 var = ((short int(*)(val* self))(var_recv->class->vft[COLOR_nit__model__MType__need_anchor]))(var_recv); /* need_anchor on <var_recv:MClassType>*/
3666 }
3667 var1 = !var;
3668 if (unlikely(!var1)) {
3669 PRINT_ERROR("Runtime error: %s", "Assert failed");
3670 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 336);
3671 fatal_exit(1);
3672 }
3673 {
3674 var2 = ((short int(*)(val* self))(var_mtype->class->vft[COLOR_nit__model__MType__need_anchor]))(var_mtype); /* need_anchor on <var_mtype:MClassType>*/
3675 }
3676 if (var2){
3677 {
3678 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_open_types (self) on <self:RapidTypeAnalysis> */
3679 var5 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_open_types].val; /* _live_open_types on <self:RapidTypeAnalysis> */
3680 if (unlikely(var5 == NULL)) {
3681 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_open_types");
3682 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 65);
3683 fatal_exit(1);
3684 }
3685 var3 = var5;
3686 RET_LABEL4:(void)0;
3687 }
3688 }
3689 {
3690 var6 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var3, var_mtype);
3691 }
3692 if (var6){
3693 goto RET_LABEL;
3694 } else {
3695 }
3696 {
3697 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_open_types (self) on <self:RapidTypeAnalysis> */
3698 var9 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_open_types].val; /* _live_open_types on <self:RapidTypeAnalysis> */
3699 if (unlikely(var9 == NULL)) {
3700 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_open_types");
3701 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 65);
3702 fatal_exit(1);
3703 }
3704 var7 = var9;
3705 RET_LABEL8:(void)0;
3706 }
3707 }
3708 {
3709 standard___standard__HashSet___standard__abstract_collection__SimpleCollection__add(var7, var_mtype); /* Direct call hash_collection#HashSet#add on <var7:HashSet[MClassType]>*/
3710 }
3711 } else {
3712 {
3713 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_types (self) on <self:RapidTypeAnalysis> */
3714 var12 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on <self:RapidTypeAnalysis> */
3715 if (unlikely(var12 == NULL)) {
3716 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types");
3717 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 60);
3718 fatal_exit(1);
3719 }
3720 var10 = var12;
3721 RET_LABEL11:(void)0;
3722 }
3723 }
3724 {
3725 var13 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var10, var_mtype);
3726 }
3727 if (var13){
3728 goto RET_LABEL;
3729 } else {
3730 }
3731 {
3732 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_types (self) on <self:RapidTypeAnalysis> */
3733 var16 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on <self:RapidTypeAnalysis> */
3734 if (unlikely(var16 == NULL)) {
3735 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types");
3736 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 60);
3737 fatal_exit(1);
3738 }
3739 var14 = var16;
3740 RET_LABEL15:(void)0;
3741 }
3742 }
3743 {
3744 standard___standard__HashSet___standard__abstract_collection__SimpleCollection__add(var14, var_mtype); /* Direct call hash_collection#HashSet#add on <var14:HashSet[MClassType]>*/
3745 }
3746 }
3747 {
3748 { /* Inline model#MClassType#mclass (var_mtype) on <var_mtype:MClassType> */
3749 var19 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on <var_mtype:MClassType> */
3750 if (unlikely(var19 == NULL)) {
3751 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
3752 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138);
3753 fatal_exit(1);
3754 }
3755 var17 = var19;
3756 RET_LABEL18:(void)0;
3757 }
3758 }
3759 var_mclass = var17;
3760 {
3761 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_classes (self) on <self:RapidTypeAnalysis> */
3762 var22 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_classes].val; /* _live_classes on <self:RapidTypeAnalysis> */
3763 if (unlikely(var22 == NULL)) {
3764 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_classes");
3765 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 69);
3766 fatal_exit(1);
3767 }
3768 var20 = var22;
3769 RET_LABEL21:(void)0;
3770 }
3771 }
3772 {
3773 var23 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var20, var_mclass);
3774 }
3775 if (var23){
3776 goto RET_LABEL;
3777 } else {
3778 }
3779 {
3780 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_classes (self) on <self:RapidTypeAnalysis> */
3781 var26 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_classes].val; /* _live_classes on <self:RapidTypeAnalysis> */
3782 if (unlikely(var26 == NULL)) {
3783 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_classes");
3784 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 69);
3785 fatal_exit(1);
3786 }
3787 var24 = var26;
3788 RET_LABEL25:(void)0;
3789 }
3790 }
3791 {
3792 standard___standard__HashSet___standard__abstract_collection__SimpleCollection__add(var24, var_mclass); /* Direct call hash_collection#HashSet#add on <var24:HashSet[MClass]>*/
3793 }
3794 {
3795 { /* Inline rapid_type_analysis#RapidTypeAnalysis#totry_methods (self) on <self:RapidTypeAnalysis> */
3796 var29 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___totry_methods].val; /* _totry_methods on <self:RapidTypeAnalysis> */
3797 if (unlikely(var29 == NULL)) {
3798 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _totry_methods");
3799 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 169);
3800 fatal_exit(1);
3801 }
3802 var27 = var29;
3803 RET_LABEL28:(void)0;
3804 }
3805 }
3806 var_ = var27;
3807 {
3808 var30 = standard___standard__HashSet___standard__abstract_collection__Collection__iterator(var_);
3809 }
3810 var_31 = var30;
3811 for(;;) {
3812 {
3813 var32 = ((short int(*)(val* self))((((long)var_31&3)?class_info[((long)var_31&3)]:var_31->class)->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_31); /* is_ok on <var_31:Iterator[MMethod]>*/
3814 }
3815 if (var32){
3816 {
3817 var33 = ((val*(*)(val* self))((((long)var_31&3)?class_info[((long)var_31&3)]:var_31->class)->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_31); /* item on <var_31:Iterator[MMethod]>*/
3818 }
3819 var_p = var33;
3820 {
3821 nit___nit__RapidTypeAnalysis___try_send(self, var_mtype, var_p); /* Direct call rapid_type_analysis#RapidTypeAnalysis#try_send on <self:RapidTypeAnalysis>*/
3822 }
3823 {
3824 ((void(*)(val* self))((((long)var_31&3)?class_info[((long)var_31&3)]:var_31->class)->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_31); /* next on <var_31:Iterator[MMethod]>*/
3825 }
3826 } else {
3827 goto BREAK_label;
3828 }
3829 }
3830 BREAK_label: (void)0;
3831 {
3832 ((void(*)(val* self))((((long)var_31&3)?class_info[((long)var_31&3)]:var_31->class)->vft[COLOR_standard__abstract_collection__Iterator__finish]))(var_31); /* finish on <var_31:Iterator[MMethod]>*/
3833 }
3834 {
3835 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_super_sends (self) on <self:RapidTypeAnalysis> */
3836 var36 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_super_sends].val; /* _live_super_sends on <self:RapidTypeAnalysis> */
3837 if (unlikely(var36 == NULL)) {
3838 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_super_sends");
3839 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 114);
3840 fatal_exit(1);
3841 }
3842 var34 = var36;
3843 RET_LABEL35:(void)0;
3844 }
3845 }
3846 var_37 = var34;
3847 {
3848 var38 = standard___standard__HashSet___standard__abstract_collection__Collection__iterator(var_37);
3849 }
3850 var_39 = var38;
3851 for(;;) {
3852 {
3853 var40 = ((short int(*)(val* self))((((long)var_39&3)?class_info[((long)var_39&3)]:var_39->class)->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_39); /* is_ok on <var_39:Iterator[MMethodDef]>*/
3854 }
3855 if (var40){
3856 {
3857 var41 = ((val*(*)(val* self))((((long)var_39&3)?class_info[((long)var_39&3)]:var_39->class)->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_39); /* item on <var_39:Iterator[MMethodDef]>*/
3858 }
3859 var_p42 = var41;
3860 {
3861 nit___nit__RapidTypeAnalysis___try_super_send(self, var_mtype, var_p42); /* Direct call rapid_type_analysis#RapidTypeAnalysis#try_super_send on <self:RapidTypeAnalysis>*/
3862 }
3863 {
3864 ((void(*)(val* self))((((long)var_39&3)?class_info[((long)var_39&3)]:var_39->class)->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_39); /* next on <var_39:Iterator[MMethodDef]>*/
3865 }
3866 } else {
3867 goto BREAK_label43;
3868 }
3869 }
3870 BREAK_label43: (void)0;
3871 {
3872 ((void(*)(val* self))((((long)var_39&3)?class_info[((long)var_39&3)]:var_39->class)->vft[COLOR_standard__abstract_collection__Iterator__finish]))(var_39); /* finish on <var_39:Iterator[MMethodDef]>*/
3873 }
3874 {
3875 { /* Inline rapid_type_analysis#RapidTypeAnalysis#totry_methods_to_remove (self) on <self:RapidTypeAnalysis> */
3876 var46 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___totry_methods_to_remove].val; /* _totry_methods_to_remove on <self:RapidTypeAnalysis> */
3877 if (unlikely(var46 == NULL)) {
3878 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _totry_methods_to_remove");
3879 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 172);
3880 fatal_exit(1);
3881 }
3882 var44 = var46;
3883 RET_LABEL45:(void)0;
3884 }
3885 }
3886 var_47 = var44;
3887 {
3888 var48 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_47);
3889 }
3890 var_49 = var48;
3891 for(;;) {
3892 {
3893 var50 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_49);
3894 }
3895 if (var50){
3896 {
3897 var51 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_49);
3898 }
3899 var_p52 = var51;
3900 {
3901 { /* Inline rapid_type_analysis#RapidTypeAnalysis#totry_methods (self) on <self:RapidTypeAnalysis> */
3902 var55 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___totry_methods].val; /* _totry_methods on <self:RapidTypeAnalysis> */
3903 if (unlikely(var55 == NULL)) {
3904 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _totry_methods");
3905 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 169);
3906 fatal_exit(1);
3907 }
3908 var53 = var55;
3909 RET_LABEL54:(void)0;
3910 }
3911 }
3912 {
3913 standard___standard__HashSet___standard__abstract_collection__RemovableCollection__remove(var53, var_p52); /* Direct call hash_collection#HashSet#remove on <var53:HashSet[MMethod]>*/
3914 }
3915 {
3916 standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_49); /* Direct call array#ArrayIterator#next on <var_49:ArrayIterator[MMethod]>*/
3917 }
3918 } else {
3919 goto BREAK_label56;
3920 }
3921 }
3922 BREAK_label56: (void)0;
3923 {
3924 standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__finish(var_49); /* Direct call array#ArrayIterator#finish on <var_49:ArrayIterator[MMethod]>*/
3925 }
3926 {
3927 { /* Inline rapid_type_analysis#RapidTypeAnalysis#totry_methods_to_remove (self) on <self:RapidTypeAnalysis> */
3928 var59 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___totry_methods_to_remove].val; /* _totry_methods_to_remove on <self:RapidTypeAnalysis> */
3929 if (unlikely(var59 == NULL)) {
3930 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _totry_methods_to_remove");
3931 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 172);
3932 fatal_exit(1);
3933 }
3934 var57 = var59;
3935 RET_LABEL58:(void)0;
3936 }
3937 }
3938 {
3939 standard___standard__AbstractArray___standard__abstract_collection__RemovableCollection__clear(var57); /* Direct call array#AbstractArray#clear on <var57:Array[MMethod]>*/
3940 }
3941 {
3942 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (self) on <self:RapidTypeAnalysis> */
3943 var62 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
3944 if (unlikely(var62 == NULL)) {
3945 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
3946 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
3947 fatal_exit(1);
3948 }
3949 var60 = var62;
3950 RET_LABEL61:(void)0;
3951 }
3952 }
3953 {
3954 var63 = nit___nit__MClassType___MType__anchor_to(var_mtype, var60, var_recv);
3955 }
3956 var_bound_mtype = var63;
3957 {
3958 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (self) on <self:RapidTypeAnalysis> */
3959 var66 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
3960 if (unlikely(var66 == NULL)) {
3961 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
3962 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
3963 fatal_exit(1);
3964 }
3965 var64 = var66;
3966 RET_LABEL65:(void)0;
3967 }
3968 }
3969 {
3970 var67 = nit___nit__MClassType___MType__collect_mclassdefs(var_bound_mtype, var64);
3971 }
3972 var_68 = var67;
3973 {
3974 var69 = ((val*(*)(val* self))((((long)var_68&3)?class_info[((long)var_68&3)]:var_68->class)->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_68); /* iterator on <var_68:Set[MClassDef]>*/
3975 }
3976 var_70 = var69;
3977 for(;;) {
3978 {
3979 var71 = ((short int(*)(val* self))((((long)var_70&3)?class_info[((long)var_70&3)]:var_70->class)->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_70); /* is_ok on <var_70:Iterator[MClassDef]>*/
3980 }
3981 if (var71){
3982 {
3983 var72 = ((val*(*)(val* self))((((long)var_70&3)?class_info[((long)var_70&3)]:var_70->class)->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_70); /* item on <var_70:Iterator[MClassDef]>*/
3984 }
3985 var_cd = var72;
3986 {
3987 { /* Inline rapid_type_analysis#RapidTypeAnalysis#modelbuilder (self) on <self:RapidTypeAnalysis> */
3988 var75 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___modelbuilder].val; /* _modelbuilder on <self:RapidTypeAnalysis> */
3989 if (unlikely(var75 == NULL)) {
3990 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder");
3991 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 53);
3992 fatal_exit(1);
3993 }
3994 var73 = var75;
3995 RET_LABEL74:(void)0;
3996 }
3997 }
3998 {
3999 var76 = nit__modelize_property___ModelBuilder___collect_attr_propdef(var73, var_cd);
4000 }
4001 var_77 = var76;
4002 {
4003 var78 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_77);
4004 }
4005 var_79 = var78;
4006 for(;;) {
4007 {
4008 var80 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_79);
4009 }
4010 if (var80){
4011 {
4012 var81 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_79);
4013 }
4014 var_npropdef = var81;
4015 {
4016 { /* Inline modelize_property#AAttrPropdef#has_value (var_npropdef) on <var_npropdef:AAttrPropdef> */
4017 var84 = var_npropdef->attrs[COLOR_nit__modelize_property__AAttrPropdef___has_value].s; /* _has_value on <var_npropdef:AAttrPropdef> */
4018 var82 = var84;
4019 RET_LABEL83:(void)0;
4020 }
4021 }
4022 var85 = !var82;
4023 if (var85){
4024 goto BREAK_label86;
4025 } else {
4026 }
4027 {
4028 { /* Inline modelize_property#AAttrPropdef#mreadpropdef (var_npropdef) on <var_npropdef:AAttrPropdef> */
4029 var89 = var_npropdef->attrs[COLOR_nit__modelize_property__AAttrPropdef___mreadpropdef].val; /* _mreadpropdef on <var_npropdef:AAttrPropdef> */
4030 var87 = var89;
4031 RET_LABEL88:(void)0;
4032 }
4033 }
4034 if (unlikely(var87 == NULL)) {
4035 PRINT_ERROR("Runtime error: %s", "Cast failed");
4036 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 362);
4037 fatal_exit(1);
4038 }
4039 var_mpropdef = var87;
4040 var90 = NEW_nit__RapidTypeVisitor(&type_nit__RapidTypeVisitor);
4041 {
4042 ((void(*)(val* self, val* p0))(var90->class->vft[COLOR_nit__rapid_type_analysis__RapidTypeVisitor__analysis_61d]))(var90, self); /* analysis= on <var90:RapidTypeVisitor>*/
4043 }
4044 {
4045 ((void(*)(val* self, val* p0))(var90->class->vft[COLOR_nit__rapid_type_analysis__RapidTypeVisitor__receiver_61d]))(var90, var_bound_mtype); /* receiver= on <var90:RapidTypeVisitor>*/
4046 }
4047 {
4048 ((void(*)(val* self, val* p0))(var90->class->vft[COLOR_nit__rapid_type_analysis__RapidTypeVisitor__mpropdef_61d]))(var90, var_mpropdef); /* mpropdef= on <var90:RapidTypeVisitor>*/
4049 }
4050 {
4051 ((void(*)(val* self))(var90->class->vft[COLOR_standard__kernel__Object__init]))(var90); /* init on <var90:RapidTypeVisitor>*/
4052 }
4053 var_v = var90;
4054 {
4055 { /* Inline parser_nodes#AAttrPropdef#n_expr (var_npropdef) on <var_npropdef:AAttrPropdef> */
4056 var93 = var_npropdef->attrs[COLOR_nit__parser_nodes__AAttrPropdef___n_expr].val; /* _n_expr on <var_npropdef:AAttrPropdef> */
4057 var91 = var93;
4058 RET_LABEL92:(void)0;
4059 }
4060 }
4061 {
4062 nit___nit__Visitor___enter_visit(var_v, var91); /* Direct call parser_nodes#Visitor#enter_visit on <var_v:RapidTypeVisitor>*/
4063 }
4064 {
4065 { /* Inline parser_nodes#AAttrPropdef#n_block (var_npropdef) on <var_npropdef:AAttrPropdef> */
4066 var96 = var_npropdef->attrs[COLOR_nit__parser_nodes__AAttrPropdef___n_block].val; /* _n_block on <var_npropdef:AAttrPropdef> */
4067 var94 = var96;
4068 RET_LABEL95:(void)0;
4069 }
4070 }
4071 {
4072 nit___nit__Visitor___enter_visit(var_v, var94); /* Direct call parser_nodes#Visitor#enter_visit on <var_v:RapidTypeVisitor>*/
4073 }
4074 BREAK_label86: (void)0;
4075 {
4076 standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_79); /* Direct call array#ArrayIterator#next on <var_79:ArrayIterator[AAttrPropdef]>*/
4077 }
4078 } else {
4079 goto BREAK_label97;
4080 }
4081 }
4082 BREAK_label97: (void)0;
4083 {
4084 standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__finish(var_79); /* Direct call array#ArrayIterator#finish on <var_79:ArrayIterator[AAttrPropdef]>*/
4085 }
4086 {
4087 ((void(*)(val* self))((((long)var_70&3)?class_info[((long)var_70&3)]:var_70->class)->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_70); /* next on <var_70:Iterator[MClassDef]>*/
4088 }
4089 } else {
4090 goto BREAK_label98;
4091 }
4092 }
4093 BREAK_label98: (void)0;
4094 {
4095 ((void(*)(val* self))((((long)var_70&3)?class_info[((long)var_70&3)]:var_70->class)->vft[COLOR_standard__abstract_collection__Iterator__finish]))(var_70); /* finish on <var_70:Iterator[MClassDef]>*/
4096 }
4097 RET_LABEL:;
4098 }
4099 /* method rapid_type_analysis#RapidTypeAnalysis#add_cast for (self: RapidTypeAnalysis, MType) */
4100 void nit___nit__RapidTypeAnalysis___add_cast(val* self, val* p0) {
4101 val* var_mtype /* var mtype: MType */;
4102 short int var /* : Bool */;
4103 val* var1 /* : HashSet[MType] */;
4104 val* var3 /* : HashSet[MType] */;
4105 val* var4 /* : HashSet[MType] */;
4106 val* var6 /* : HashSet[MType] */;
4107 var_mtype = p0;
4108 {
4109 var = ((short int(*)(val* self))(var_mtype->class->vft[COLOR_nit__model__MType__need_anchor]))(var_mtype); /* need_anchor on <var_mtype:MType>*/
4110 }
4111 if (var){
4112 {
4113 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_open_cast_types (self) on <self:RapidTypeAnalysis> */
4114 var3 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_open_cast_types].val; /* _live_open_cast_types on <self:RapidTypeAnalysis> */
4115 if (unlikely(var3 == NULL)) {
4116 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_open_cast_types");
4117 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 75);
4118 fatal_exit(1);
4119 }
4120 var1 = var3;
4121 RET_LABEL2:(void)0;
4122 }
4123 }
4124 {
4125 standard___standard__HashSet___standard__abstract_collection__SimpleCollection__add(var1, var_mtype); /* Direct call hash_collection#HashSet#add on <var1:HashSet[MType]>*/
4126 }
4127 } else {
4128 {
4129 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_cast_types (self) on <self:RapidTypeAnalysis> */
4130 var6 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_cast_types].val; /* _live_cast_types on <self:RapidTypeAnalysis> */
4131 if (unlikely(var6 == NULL)) {
4132 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_cast_types");
4133 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 72);
4134 fatal_exit(1);
4135 }
4136 var4 = var6;
4137 RET_LABEL5:(void)0;
4138 }
4139 }
4140 {
4141 standard___standard__HashSet___standard__abstract_collection__SimpleCollection__add(var4, var_mtype); /* Direct call hash_collection#HashSet#add on <var4:HashSet[MType]>*/
4142 }
4143 }
4144 RET_LABEL:;
4145 }
4146 /* method rapid_type_analysis#RapidTypeAnalysis#try_send for (self: RapidTypeAnalysis, MClassType, MMethod) */
4147 void nit___nit__RapidTypeAnalysis___try_send(val* self, val* p0, val* p1) {
4148 val* var_recv /* var recv: MClassType */;
4149 val* var_mproperty /* var mproperty: MMethod */;
4150 val* var /* : MClass */;
4151 val* var2 /* : MClass */;
4152 val* var3 /* : MClassDef */;
4153 val* var5 /* : MClassDef */;
4154 val* var6 /* : MClassType */;
4155 val* var8 /* : MClassType */;
4156 val* var9 /* : MModule */;
4157 val* var11 /* : MModule */;
4158 short int var12 /* : Bool */;
4159 short int var13 /* : Bool */;
4160 val* var14 /* : MModule */;
4161 val* var16 /* : MModule */;
4162 val* var17 /* : MPropDef */;
4163 val* var_d /* var d: MMethodDef */;
4164 var_recv = p0;
4165 var_mproperty = p1;
4166 {
4167 { /* Inline model#MClassType#mclass (var_recv) on <var_recv:MClassType> */
4168 var2 = var_recv->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on <var_recv:MClassType> */
4169 if (unlikely(var2 == NULL)) {
4170 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
4171 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138);
4172 fatal_exit(1);
4173 }
4174 var = var2;
4175 RET_LABEL1:(void)0;
4176 }
4177 }
4178 {
4179 { /* Inline model#MClass#intro (var) on <var:MClass> */
4180 var5 = var->attrs[COLOR_nit__model__MClass___intro].val; /* _intro on <var:MClass> */
4181 if (unlikely(var5 == NULL)) {
4182 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro");
4183 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 460);
4184 fatal_exit(1);
4185 }
4186 var3 = var5;
4187 RET_LABEL4:(void)0;
4188 }
4189 }
4190 {
4191 { /* Inline model#MClassDef#bound_mtype (var3) on <var3:MClassDef> */
4192 var8 = var3->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on <var3:MClassDef> */
4193 if (unlikely(var8 == NULL)) {
4194 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype");
4195 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 556);
4196 fatal_exit(1);
4197 }
4198 var6 = var8;
4199 RET_LABEL7:(void)0;
4200 }
4201 }
4202 var_recv = var6;
4203 {
4204 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (self) on <self:RapidTypeAnalysis> */
4205 var11 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
4206 if (unlikely(var11 == NULL)) {
4207 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
4208 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
4209 fatal_exit(1);
4210 }
4211 var9 = var11;
4212 RET_LABEL10:(void)0;
4213 }
4214 }
4215 {
4216 var12 = nit___nit__MType___has_mproperty(var_recv, var9, var_mproperty);
4217 }
4218 var13 = !var12;
4219 if (var13){
4220 goto RET_LABEL;
4221 } else {
4222 }
4223 {
4224 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (self) on <self:RapidTypeAnalysis> */
4225 var16 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
4226 if (unlikely(var16 == NULL)) {
4227 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
4228 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
4229 fatal_exit(1);
4230 }
4231 var14 = var16;
4232 RET_LABEL15:(void)0;
4233 }
4234 }
4235 {
4236 var17 = nit___nit__MProperty___lookup_first_definition(var_mproperty, var14, var_recv);
4237 }
4238 var_d = var17;
4239 {
4240 nit___nit__RapidTypeAnalysis___add_call(self, var_d); /* Direct call rapid_type_analysis#RapidTypeAnalysis#add_call on <self:RapidTypeAnalysis>*/
4241 }
4242 RET_LABEL:;
4243 }
4244 /* method rapid_type_analysis#RapidTypeAnalysis#add_call for (self: RapidTypeAnalysis, MMethodDef) */
4245 void nit___nit__RapidTypeAnalysis___add_call(val* self, val* p0) {
4246 val* var_mpropdef /* var mpropdef: MMethodDef */;
4247 val* var /* : HashSet[MMethodDef] */;
4248 val* var2 /* : HashSet[MMethodDef] */;
4249 short int var3 /* : Bool */;
4250 val* var4 /* : HashSet[MMethodDef] */;
4251 val* var6 /* : HashSet[MMethodDef] */;
4252 val* var7 /* : List[MMethodDef] */;
4253 val* var9 /* : List[MMethodDef] */;
4254 val* var10 /* : MProperty */;
4255 val* var12 /* : MProperty */;
4256 val* var_mproperty /* var mproperty: MMethod */;
4257 val* var13 /* : Array[MPropDef] */;
4258 val* var15 /* : Array[MPropDef] */;
4259 long var16 /* : Int */;
4260 long var18 /* : Int */;
4261 short int var19 /* : Bool */;
4262 short int var21 /* : Bool */;
4263 int cltype;
4264 int idtype;
4265 const char* var_class_name;
4266 short int var22 /* : Bool */;
4267 val* var23 /* : Array[MPropDef] */;
4268 val* var25 /* : Array[MPropDef] */;
4269 val* var_ /* var : Array[MMethodDef] */;
4270 val* var26 /* : ArrayIterator[nullable Object] */;
4271 val* var_27 /* var : ArrayIterator[MMethodDef] */;
4272 short int var28 /* : Bool */;
4273 val* var29 /* : nullable Object */;
4274 val* var_d /* var d: MMethodDef */;
4275 val* var30 /* : HashSet[MMethodDef] */;
4276 val* var32 /* : HashSet[MMethodDef] */;
4277 short int var33 /* : Bool */;
4278 short int var34 /* : Bool */;
4279 val* var35 /* : Array[MMethod] */;
4280 val* var37 /* : Array[MMethod] */;
4281 val* var38 /* : MProperty */;
4282 val* var40 /* : MProperty */;
4283 var_mpropdef = p0;
4284 {
4285 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_methoddefs (self) on <self:RapidTypeAnalysis> */
4286 var2 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_methoddefs].val; /* _live_methoddefs on <self:RapidTypeAnalysis> */
4287 if (unlikely(var2 == NULL)) {
4288 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_methoddefs");
4289 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 79);
4290 fatal_exit(1);
4291 }
4292 var = var2;
4293 RET_LABEL1:(void)0;
4294 }
4295 }
4296 {
4297 var3 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var, var_mpropdef);
4298 }
4299 if (var3){
4300 goto RET_LABEL;
4301 } else {
4302 }
4303 {
4304 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_methoddefs (self) on <self:RapidTypeAnalysis> */
4305 var6 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_methoddefs].val; /* _live_methoddefs on <self:RapidTypeAnalysis> */
4306 if (unlikely(var6 == NULL)) {
4307 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_methoddefs");
4308 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 79);
4309 fatal_exit(1);
4310 }
4311 var4 = var6;
4312 RET_LABEL5:(void)0;
4313 }
4314 }
4315 {
4316 standard___standard__HashSet___standard__abstract_collection__SimpleCollection__add(var4, var_mpropdef); /* Direct call hash_collection#HashSet#add on <var4:HashSet[MMethodDef]>*/
4317 }
4318 {
4319 { /* Inline rapid_type_analysis#RapidTypeAnalysis#todo (self) on <self:RapidTypeAnalysis> */
4320 var9 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___todo].val; /* _todo on <self:RapidTypeAnalysis> */
4321 if (unlikely(var9 == NULL)) {
4322 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _todo");
4323 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 179);
4324 fatal_exit(1);
4325 }
4326 var7 = var9;
4327 RET_LABEL8:(void)0;
4328 }
4329 }
4330 {
4331 standard___standard__Sequence___SimpleCollection__add(var7, var_mpropdef); /* Direct call abstract_collection#Sequence#add on <var7:List[MMethodDef]>*/
4332 }
4333 {
4334 { /* Inline model#MPropDef#mproperty (var_mpropdef) on <var_mpropdef:MMethodDef> */
4335 var12 = var_mpropdef->attrs[COLOR_nit__model__MPropDef___mproperty].val; /* _mproperty on <var_mpropdef:MMethodDef> */
4336 if (unlikely(var12 == NULL)) {
4337 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mproperty");
4338 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2212);
4339 fatal_exit(1);
4340 }
4341 var10 = var12;
4342 RET_LABEL11:(void)0;
4343 }
4344 }
4345 var_mproperty = var10;
4346 {
4347 { /* Inline model#MProperty#mpropdefs (var_mproperty) on <var_mproperty:MMethod> */
4348 var15 = var_mproperty->attrs[COLOR_nit__model__MProperty___mpropdefs].val; /* _mpropdefs on <var_mproperty:MMethod> */
4349 if (unlikely(var15 == NULL)) {
4350 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdefs");
4351 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1963);
4352 fatal_exit(1);
4353 }
4354 var13 = var15;
4355 RET_LABEL14:(void)0;
4356 }
4357 }
4358 {
4359 { /* Inline array#AbstractArrayRead#length (var13) on <var13:Array[MPropDef](Array[MMethodDef])> */
4360 var18 = var13->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on <var13:Array[MPropDef](Array[MMethodDef])> */
4361 var16 = var18;
4362 RET_LABEL17:(void)0;
4363 }
4364 }
4365 {
4366 { /* Inline kernel#Int#<= (var16,1l) on <var16:Int> */
4367 /* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */
4368 /* <1l:Int> isa OTHER */
4369 var21 = 1; /* easy <1l:Int> isa OTHER*/
4370 if (unlikely(!var21)) {
4371 var_class_name = type_standard__Int.name;
4372 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
4373 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 533);
4374 fatal_exit(1);
4375 }
4376 var22 = var16 <= 1l;
4377 var19 = var22;
4378 goto RET_LABEL20;
4379 RET_LABEL20:(void)0;
4380 }
4381 }
4382 if (var19){
4383 goto RET_LABEL;
4384 } else {
4385 }
4386 {
4387 { /* Inline model#MProperty#mpropdefs (var_mproperty) on <var_mproperty:MMethod> */
4388 var25 = var_mproperty->attrs[COLOR_nit__model__MProperty___mpropdefs].val; /* _mpropdefs on <var_mproperty:MMethod> */
4389 if (unlikely(var25 == NULL)) {
4390 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdefs");
4391 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1963);
4392 fatal_exit(1);
4393 }
4394 var23 = var25;
4395 RET_LABEL24:(void)0;
4396 }
4397 }
4398 var_ = var23;
4399 {
4400 var26 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_);
4401 }
4402 var_27 = var26;
4403 for(;;) {
4404 {
4405 var28 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_27);
4406 }
4407 if (var28){
4408 {
4409 var29 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_27);
4410 }
4411 var_d = var29;
4412 {
4413 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_methoddefs (self) on <self:RapidTypeAnalysis> */
4414 var32 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_methoddefs].val; /* _live_methoddefs on <self:RapidTypeAnalysis> */
4415 if (unlikely(var32 == NULL)) {
4416 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_methoddefs");
4417 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 79);
4418 fatal_exit(1);
4419 }
4420 var30 = var32;
4421 RET_LABEL31:(void)0;
4422 }
4423 }
4424 {
4425 var33 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var30, var_d);
4426 }
4427 var34 = !var33;
4428 if (var34){
4429 goto RET_LABEL;
4430 } else {
4431 }
4432 {
4433 standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_27); /* Direct call array#ArrayIterator#next on <var_27:ArrayIterator[MMethodDef]>*/
4434 }
4435 } else {
4436 goto BREAK_label;
4437 }
4438 }
4439 BREAK_label: (void)0;
4440 {
4441 standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__finish(var_27); /* Direct call array#ArrayIterator#finish on <var_27:ArrayIterator[MMethodDef]>*/
4442 }
4443 {
4444 { /* Inline rapid_type_analysis#RapidTypeAnalysis#totry_methods_to_remove (self) on <self:RapidTypeAnalysis> */
4445 var37 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___totry_methods_to_remove].val; /* _totry_methods_to_remove on <self:RapidTypeAnalysis> */
4446 if (unlikely(var37 == NULL)) {
4447 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _totry_methods_to_remove");
4448 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 172);
4449 fatal_exit(1);
4450 }
4451 var35 = var37;
4452 RET_LABEL36:(void)0;
4453 }
4454 }
4455 {
4456 { /* Inline model#MPropDef#mproperty (var_mpropdef) on <var_mpropdef:MMethodDef> */
4457 var40 = var_mpropdef->attrs[COLOR_nit__model__MPropDef___mproperty].val; /* _mproperty on <var_mpropdef:MMethodDef> */
4458 if (unlikely(var40 == NULL)) {
4459 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mproperty");
4460 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2212);
4461 fatal_exit(1);
4462 }
4463 var38 = var40;
4464 RET_LABEL39:(void)0;
4465 }
4466 }
4467 {
4468 standard___standard__Array___standard__abstract_collection__SimpleCollection__add(var35, var38); /* Direct call array#Array#add on <var35:Array[MMethod]>*/
4469 }
4470 RET_LABEL:;
4471 }
4472 /* method rapid_type_analysis#RapidTypeAnalysis#add_send for (self: RapidTypeAnalysis, MType, MMethod) */
4473 void nit___nit__RapidTypeAnalysis___add_send(val* self, val* p0, val* p1) {
4474 val* var_recv /* var recv: MType */;
4475 val* var_mproperty /* var mproperty: MMethod */;
4476 val* var /* : HashSet[MMethod] */;
4477 val* var2 /* : HashSet[MMethod] */;
4478 short int var3 /* : Bool */;
4479 val* var4 /* : HashSet[MMethod] */;
4480 val* var6 /* : HashSet[MMethod] */;
4481 val* var7 /* : HashSet[MMethod] */;
4482 val* var9 /* : HashSet[MMethod] */;
4483 val* var10 /* : Array[MPropDef] */;
4484 val* var12 /* : Array[MPropDef] */;
4485 long var13 /* : Int */;
4486 long var15 /* : Int */;
4487 short int var16 /* : Bool */;
4488 short int var18 /* : Bool */;
4489 val* var19 /* : Array[MPropDef] */;
4490 val* var21 /* : Array[MPropDef] */;
4491 val* var22 /* : nullable Object */;
4492 val* var_d /* var d: MMethodDef */;
4493 val* var23 /* : HashSet[MMethod] */;
4494 val* var25 /* : HashSet[MMethod] */;
4495 val* var26 /* : HashSet[MClass] */;
4496 val* var28 /* : HashSet[MClass] */;
4497 val* var_ /* var : HashSet[MClass] */;
4498 val* var29 /* : Iterator[nullable Object] */;
4499 val* var_30 /* var : Iterator[MClass] */;
4500 short int var31 /* : Bool */;
4501 val* var32 /* : nullable Object */;
4502 val* var_c /* var c: MClass */;
4503 val* var33 /* : MClassDef */;
4504 val* var35 /* : MClassDef */;
4505 val* var36 /* : MClassType */;
4506 val* var38 /* : MClassType */;
4507 var_recv = p0;
4508 var_mproperty = p1;
4509 {
4510 { /* Inline rapid_type_analysis#RapidTypeAnalysis#try_methods (self) on <self:RapidTypeAnalysis> */
4511 var2 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___try_methods].val; /* _try_methods on <self:RapidTypeAnalysis> */
4512 if (unlikely(var2 == NULL)) {
4513 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _try_methods");
4514 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 175);
4515 fatal_exit(1);
4516 }
4517 var = var2;
4518 RET_LABEL1:(void)0;
4519 }
4520 }
4521 {
4522 var3 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var, var_mproperty);
4523 }
4524 if (var3){
4525 goto RET_LABEL;
4526 } else {
4527 }
4528 {
4529 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_methods (self) on <self:RapidTypeAnalysis> */
4530 var6 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_methods].val; /* _live_methods on <self:RapidTypeAnalysis> */
4531 if (unlikely(var6 == NULL)) {
4532 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_methods");
4533 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 82);
4534 fatal_exit(1);
4535 }
4536 var4 = var6;
4537 RET_LABEL5:(void)0;
4538 }
4539 }
4540 {
4541 standard___standard__HashSet___standard__abstract_collection__SimpleCollection__add(var4, var_mproperty); /* Direct call hash_collection#HashSet#add on <var4:HashSet[MMethod]>*/
4542 }
4543 {
4544 { /* Inline rapid_type_analysis#RapidTypeAnalysis#try_methods (self) on <self:RapidTypeAnalysis> */
4545 var9 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___try_methods].val; /* _try_methods on <self:RapidTypeAnalysis> */
4546 if (unlikely(var9 == NULL)) {
4547 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _try_methods");
4548 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 175);
4549 fatal_exit(1);
4550 }
4551 var7 = var9;
4552 RET_LABEL8:(void)0;
4553 }
4554 }
4555 {
4556 standard___standard__HashSet___standard__abstract_collection__SimpleCollection__add(var7, var_mproperty); /* Direct call hash_collection#HashSet#add on <var7:HashSet[MMethod]>*/
4557 }
4558 {
4559 { /* Inline model#MProperty#mpropdefs (var_mproperty) on <var_mproperty:MMethod> */
4560 var12 = var_mproperty->attrs[COLOR_nit__model__MProperty___mpropdefs].val; /* _mpropdefs on <var_mproperty:MMethod> */
4561 if (unlikely(var12 == NULL)) {
4562 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdefs");
4563 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1963);
4564 fatal_exit(1);
4565 }
4566 var10 = var12;
4567 RET_LABEL11:(void)0;
4568 }
4569 }
4570 {
4571 { /* Inline array#AbstractArrayRead#length (var10) on <var10:Array[MPropDef](Array[MMethodDef])> */
4572 var15 = var10->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on <var10:Array[MPropDef](Array[MMethodDef])> */
4573 var13 = var15;
4574 RET_LABEL14:(void)0;
4575 }
4576 }
4577 {
4578 { /* Inline kernel#Int#== (var13,1l) on <var13:Int> */
4579 var18 = var13 == 1l;
4580 var16 = var18;
4581 goto RET_LABEL17;
4582 RET_LABEL17:(void)0;
4583 }
4584 }
4585 if (var16){
4586 {
4587 { /* Inline model#MProperty#mpropdefs (var_mproperty) on <var_mproperty:MMethod> */
4588 var21 = var_mproperty->attrs[COLOR_nit__model__MProperty___mpropdefs].val; /* _mpropdefs on <var_mproperty:MMethod> */
4589 if (unlikely(var21 == NULL)) {
4590 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdefs");
4591 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1963);
4592 fatal_exit(1);
4593 }
4594 var19 = var21;
4595 RET_LABEL20:(void)0;
4596 }
4597 }
4598 {
4599 var22 = standard___standard__SequenceRead___Collection__first(var19);
4600 }
4601 var_d = var22;
4602 {
4603 nit___nit__RapidTypeAnalysis___add_call(self, var_d); /* Direct call rapid_type_analysis#RapidTypeAnalysis#add_call on <self:RapidTypeAnalysis>*/
4604 }
4605 goto RET_LABEL;
4606 } else {
4607 }
4608 {
4609 { /* Inline rapid_type_analysis#RapidTypeAnalysis#totry_methods (self) on <self:RapidTypeAnalysis> */
4610 var25 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___totry_methods].val; /* _totry_methods on <self:RapidTypeAnalysis> */
4611 if (unlikely(var25 == NULL)) {
4612 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _totry_methods");
4613 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 169);
4614 fatal_exit(1);
4615 }
4616 var23 = var25;
4617 RET_LABEL24:(void)0;
4618 }
4619 }
4620 {
4621 standard___standard__HashSet___standard__abstract_collection__SimpleCollection__add(var23, var_mproperty); /* Direct call hash_collection#HashSet#add on <var23:HashSet[MMethod]>*/
4622 }
4623 {
4624 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_classes (self) on <self:RapidTypeAnalysis> */
4625 var28 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_classes].val; /* _live_classes on <self:RapidTypeAnalysis> */
4626 if (unlikely(var28 == NULL)) {
4627 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_classes");
4628 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 69);
4629 fatal_exit(1);
4630 }
4631 var26 = var28;
4632 RET_LABEL27:(void)0;
4633 }
4634 }
4635 var_ = var26;
4636 {
4637 var29 = standard___standard__HashSet___standard__abstract_collection__Collection__iterator(var_);
4638 }
4639 var_30 = var29;
4640 for(;;) {
4641 {
4642 var31 = ((short int(*)(val* self))((((long)var_30&3)?class_info[((long)var_30&3)]:var_30->class)->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_30); /* is_ok on <var_30:Iterator[MClass]>*/
4643 }
4644 if (var31){
4645 {
4646 var32 = ((val*(*)(val* self))((((long)var_30&3)?class_info[((long)var_30&3)]:var_30->class)->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_30); /* item on <var_30:Iterator[MClass]>*/
4647 }
4648 var_c = var32;
4649 {
4650 { /* Inline model#MClass#intro (var_c) on <var_c:MClass> */
4651 var35 = var_c->attrs[COLOR_nit__model__MClass___intro].val; /* _intro on <var_c:MClass> */
4652 if (unlikely(var35 == NULL)) {
4653 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro");
4654 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 460);
4655 fatal_exit(1);
4656 }
4657 var33 = var35;
4658 RET_LABEL34:(void)0;
4659 }
4660 }
4661 {
4662 { /* Inline model#MClassDef#bound_mtype (var33) on <var33:MClassDef> */
4663 var38 = var33->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on <var33:MClassDef> */
4664 if (unlikely(var38 == NULL)) {
4665 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype");
4666 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 556);
4667 fatal_exit(1);
4668 }
4669 var36 = var38;
4670 RET_LABEL37:(void)0;
4671 }
4672 }
4673 {
4674 nit___nit__RapidTypeAnalysis___try_send(self, var36, var_mproperty); /* Direct call rapid_type_analysis#RapidTypeAnalysis#try_send on <self:RapidTypeAnalysis>*/
4675 }
4676 {
4677 ((void(*)(val* self))((((long)var_30&3)?class_info[((long)var_30&3)]:var_30->class)->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_30); /* next on <var_30:Iterator[MClass]>*/
4678 }
4679 } else {
4680 goto BREAK_label;
4681 }
4682 }
4683 BREAK_label: (void)0;
4684 {
4685 ((void(*)(val* self))((((long)var_30&3)?class_info[((long)var_30&3)]:var_30->class)->vft[COLOR_standard__abstract_collection__Iterator__finish]))(var_30); /* finish on <var_30:Iterator[MClass]>*/
4686 }
4687 RET_LABEL:;
4688 }
4689 /* method rapid_type_analysis#RapidTypeAnalysis#try_super_send for (self: RapidTypeAnalysis, MClassType, MMethodDef) */
4690 void nit___nit__RapidTypeAnalysis___try_super_send(val* self, val* p0, val* p1) {
4691 val* var_recv /* var recv: MClassType */;
4692 val* var_mpropdef /* var mpropdef: MMethodDef */;
4693 val* var /* : MClass */;
4694 val* var2 /* : MClass */;
4695 val* var3 /* : MClassDef */;
4696 val* var5 /* : MClassDef */;
4697 val* var6 /* : MClassType */;
4698 val* var8 /* : MClassType */;
4699 val* var9 /* : MModule */;
4700 val* var11 /* : MModule */;
4701 val* var12 /* : Set[MClassDef] */;
4702 val* var13 /* : MClassDef */;
4703 val* var15 /* : MClassDef */;
4704 short int var16 /* : Bool */;
4705 short int var17 /* : Bool */;
4706 val* var18 /* : MModule */;
4707 val* var20 /* : MModule */;
4708 val* var21 /* : MPropDef */;
4709 val* var_d /* var d: MMethodDef */;
4710 var_recv = p0;
4711 var_mpropdef = p1;
4712 {
4713 { /* Inline model#MClassType#mclass (var_recv) on <var_recv:MClassType> */
4714 var2 = var_recv->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on <var_recv:MClassType> */
4715 if (unlikely(var2 == NULL)) {
4716 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
4717 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138);
4718 fatal_exit(1);
4719 }
4720 var = var2;
4721 RET_LABEL1:(void)0;
4722 }
4723 }
4724 {
4725 { /* Inline model#MClass#intro (var) on <var:MClass> */
4726 var5 = var->attrs[COLOR_nit__model__MClass___intro].val; /* _intro on <var:MClass> */
4727 if (unlikely(var5 == NULL)) {
4728 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro");
4729 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 460);
4730 fatal_exit(1);
4731 }
4732 var3 = var5;
4733 RET_LABEL4:(void)0;
4734 }
4735 }
4736 {
4737 { /* Inline model#MClassDef#bound_mtype (var3) on <var3:MClassDef> */
4738 var8 = var3->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on <var3:MClassDef> */
4739 if (unlikely(var8 == NULL)) {
4740 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype");
4741 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 556);
4742 fatal_exit(1);
4743 }
4744 var6 = var8;
4745 RET_LABEL7:(void)0;
4746 }
4747 }
4748 var_recv = var6;
4749 {
4750 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (self) on <self:RapidTypeAnalysis> */
4751 var11 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
4752 if (unlikely(var11 == NULL)) {
4753 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
4754 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
4755 fatal_exit(1);
4756 }
4757 var9 = var11;
4758 RET_LABEL10:(void)0;
4759 }
4760 }
4761 {
4762 var12 = nit___nit__MClassType___MType__collect_mclassdefs(var_recv, var9);
4763 }
4764 {
4765 { /* Inline model#MPropDef#mclassdef (var_mpropdef) on <var_mpropdef:MMethodDef> */
4766 var15 = var_mpropdef->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on <var_mpropdef:MMethodDef> */
4767 if (unlikely(var15 == NULL)) {
4768 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef");
4769 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2209);
4770 fatal_exit(1);
4771 }
4772 var13 = var15;
4773 RET_LABEL14:(void)0;
4774 }
4775 }
4776 {
4777 var16 = ((short int(*)(val* self, val* p0))((((long)var12&3)?class_info[((long)var12&3)]:var12->class)->vft[COLOR_standard__abstract_collection__Collection__has]))(var12, var13); /* has on <var12:Set[MClassDef]>*/
4778 }
4779 var17 = !var16;
4780 if (var17){
4781 goto RET_LABEL;
4782 } else {
4783 }
4784 {
4785 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (self) on <self:RapidTypeAnalysis> */
4786 var20 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
4787 if (unlikely(var20 == NULL)) {
4788 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
4789 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
4790 fatal_exit(1);
4791 }
4792 var18 = var20;
4793 RET_LABEL19:(void)0;
4794 }
4795 }
4796 {
4797 var21 = nit___nit__MPropDef___lookup_next_definition(var_mpropdef, var18, var_recv);
4798 }
4799 var_d = var21;
4800 {
4801 nit___nit__RapidTypeAnalysis___add_call(self, var_d); /* Direct call rapid_type_analysis#RapidTypeAnalysis#add_call on <self:RapidTypeAnalysis>*/
4802 }
4803 RET_LABEL:;
4804 }
4805 /* method rapid_type_analysis#RapidTypeAnalysis#add_super_send for (self: RapidTypeAnalysis, MType, MMethodDef) */
4806 void nit___nit__RapidTypeAnalysis___add_super_send(val* self, val* p0, val* p1) {
4807 val* var_recv /* var recv: MType */;
4808 val* var_mpropdef /* var mpropdef: MMethodDef */;
4809 short int var /* : Bool */;
4810 short int var2 /* : Bool */;
4811 val* var3 /* : HashSet[MMethodDef] */;
4812 val* var5 /* : HashSet[MMethodDef] */;
4813 short int var6 /* : Bool */;
4814 val* var7 /* : HashSet[MMethodDef] */;
4815 val* var9 /* : HashSet[MMethodDef] */;
4816 val* var10 /* : HashSet[MClass] */;
4817 val* var12 /* : HashSet[MClass] */;
4818 val* var_ /* var : HashSet[MClass] */;
4819 val* var13 /* : Iterator[nullable Object] */;
4820 val* var_14 /* var : Iterator[MClass] */;
4821 short int var15 /* : Bool */;
4822 val* var16 /* : nullable Object */;
4823 val* var_c /* var c: MClass */;
4824 val* var17 /* : MClassDef */;
4825 val* var19 /* : MClassDef */;
4826 val* var20 /* : MClassType */;
4827 val* var22 /* : MClassType */;
4828 var_recv = p0;
4829 var_mpropdef = p1;
4830 {
4831 { /* Inline modelize_property#MPropDef#has_supercall (var_mpropdef) on <var_mpropdef:MMethodDef> */
4832 var2 = var_mpropdef->attrs[COLOR_nit__modelize_property__MPropDef___has_supercall].s; /* _has_supercall on <var_mpropdef:MMethodDef> */
4833 var = var2;
4834 RET_LABEL1:(void)0;
4835 }
4836 }
4837 if (unlikely(!var)) {
4838 PRINT_ERROR("Runtime error: %s", "Assert failed");
4839 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 434);
4840 fatal_exit(1);
4841 }
4842 {
4843 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_super_sends (self) on <self:RapidTypeAnalysis> */
4844 var5 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_super_sends].val; /* _live_super_sends on <self:RapidTypeAnalysis> */
4845 if (unlikely(var5 == NULL)) {
4846 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_super_sends");
4847 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 114);
4848 fatal_exit(1);
4849 }
4850 var3 = var5;
4851 RET_LABEL4:(void)0;
4852 }
4853 }
4854 {
4855 var6 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var3, var_mpropdef);
4856 }
4857 if (var6){
4858 goto RET_LABEL;
4859 } else {
4860 }
4861 {
4862 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_super_sends (self) on <self:RapidTypeAnalysis> */
4863 var9 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_super_sends].val; /* _live_super_sends on <self:RapidTypeAnalysis> */
4864 if (unlikely(var9 == NULL)) {
4865 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_super_sends");
4866 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 114);
4867 fatal_exit(1);
4868 }
4869 var7 = var9;
4870 RET_LABEL8:(void)0;
4871 }
4872 }
4873 {
4874 standard___standard__HashSet___standard__abstract_collection__SimpleCollection__add(var7, var_mpropdef); /* Direct call hash_collection#HashSet#add on <var7:HashSet[MMethodDef]>*/
4875 }
4876 {
4877 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_classes (self) on <self:RapidTypeAnalysis> */
4878 var12 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_classes].val; /* _live_classes on <self:RapidTypeAnalysis> */
4879 if (unlikely(var12 == NULL)) {
4880 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_classes");
4881 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 69);
4882 fatal_exit(1);
4883 }
4884 var10 = var12;
4885 RET_LABEL11:(void)0;
4886 }
4887 }
4888 var_ = var10;
4889 {
4890 var13 = standard___standard__HashSet___standard__abstract_collection__Collection__iterator(var_);
4891 }
4892 var_14 = var13;
4893 for(;;) {
4894 {
4895 var15 = ((short int(*)(val* self))((((long)var_14&3)?class_info[((long)var_14&3)]:var_14->class)->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_14); /* is_ok on <var_14:Iterator[MClass]>*/
4896 }
4897 if (var15){
4898 {
4899 var16 = ((val*(*)(val* self))((((long)var_14&3)?class_info[((long)var_14&3)]:var_14->class)->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_14); /* item on <var_14:Iterator[MClass]>*/
4900 }
4901 var_c = var16;
4902 {
4903 { /* Inline model#MClass#intro (var_c) on <var_c:MClass> */
4904 var19 = var_c->attrs[COLOR_nit__model__MClass___intro].val; /* _intro on <var_c:MClass> */
4905 if (unlikely(var19 == NULL)) {
4906 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro");
4907 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 460);
4908 fatal_exit(1);
4909 }
4910 var17 = var19;
4911 RET_LABEL18:(void)0;
4912 }
4913 }
4914 {
4915 { /* Inline model#MClassDef#bound_mtype (var17) on <var17:MClassDef> */
4916 var22 = var17->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on <var17:MClassDef> */
4917 if (unlikely(var22 == NULL)) {
4918 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype");
4919 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 556);
4920 fatal_exit(1);
4921 }
4922 var20 = var22;
4923 RET_LABEL21:(void)0;
4924 }
4925 }
4926 {
4927 nit___nit__RapidTypeAnalysis___try_super_send(self, var20, var_mpropdef); /* Direct call rapid_type_analysis#RapidTypeAnalysis#try_super_send on <self:RapidTypeAnalysis>*/
4928 }
4929 {
4930 ((void(*)(val* self))((((long)var_14&3)?class_info[((long)var_14&3)]:var_14->class)->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_14); /* next on <var_14:Iterator[MClass]>*/
4931 }
4932 } else {
4933 goto BREAK_label;
4934 }
4935 }
4936 BREAK_label: (void)0;
4937 {
4938 ((void(*)(val* self))((((long)var_14&3)?class_info[((long)var_14&3)]:var_14->class)->vft[COLOR_standard__abstract_collection__Iterator__finish]))(var_14); /* finish on <var_14:Iterator[MClass]>*/
4939 }
4940 RET_LABEL:;
4941 }
4942 /* method rapid_type_analysis#RapidTypeAnalysis#init for (self: RapidTypeAnalysis) */
4943 void nit___nit__RapidTypeAnalysis___standard__kernel__Object__init(val* self) {
4944 {
4945 ((void(*)(val* self))(self->class->vft[COLOR_nit___nit__RapidTypeAnalysis___standard__kernel__Object__init]))(self); /* init on <self:RapidTypeAnalysis>*/
4946 }
4947 RET_LABEL:;
4948 }
4949 /* method rapid_type_analysis#RapidTypeVisitor#analysis for (self: RapidTypeVisitor): RapidTypeAnalysis */
4950 val* nit___nit__RapidTypeVisitor___analysis(val* self) {
4951 val* var /* : RapidTypeAnalysis */;
4952 val* var1 /* : RapidTypeAnalysis */;
4953 var1 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <self:RapidTypeVisitor> */
4954 if (unlikely(var1 == NULL)) {
4955 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
4956 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 447);
4957 fatal_exit(1);
4958 }
4959 var = var1;
4960 RET_LABEL:;
4961 return var;
4962 }
4963 /* method rapid_type_analysis#RapidTypeVisitor#analysis= for (self: RapidTypeVisitor, RapidTypeAnalysis) */
4964 void nit___nit__RapidTypeVisitor___analysis_61d(val* self, val* p0) {
4965 self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___analysis].val = p0; /* _analysis on <self:RapidTypeVisitor> */
4966 RET_LABEL:;
4967 }
4968 /* method rapid_type_analysis#RapidTypeVisitor#receiver for (self: RapidTypeVisitor): MClassType */
4969 val* nit___nit__RapidTypeVisitor___receiver(val* self) {
4970 val* var /* : MClassType */;
4971 val* var1 /* : MClassType */;
4972 var1 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___receiver].val; /* _receiver on <self:RapidTypeVisitor> */
4973 if (unlikely(var1 == NULL)) {
4974 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _receiver");
4975 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 448);
4976 fatal_exit(1);
4977 }
4978 var = var1;
4979 RET_LABEL:;
4980 return var;
4981 }
4982 /* method rapid_type_analysis#RapidTypeVisitor#receiver= for (self: RapidTypeVisitor, MClassType) */
4983 void nit___nit__RapidTypeVisitor___receiver_61d(val* self, val* p0) {
4984 self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___receiver].val = p0; /* _receiver on <self:RapidTypeVisitor> */
4985 RET_LABEL:;
4986 }
4987 /* method rapid_type_analysis#RapidTypeVisitor#mpropdef= for (self: RapidTypeVisitor, MPropDef) */
4988 void nit___nit__RapidTypeVisitor___mpropdef_61d(val* self, val* p0) {
4989 self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___mpropdef].val = p0; /* _mpropdef on <self:RapidTypeVisitor> */
4990 RET_LABEL:;
4991 }
4992 /* method rapid_type_analysis#RapidTypeVisitor#init for (self: RapidTypeVisitor) */
4993 void nit___nit__RapidTypeVisitor___standard__kernel__Object__init(val* self) {
4994 val* var /* : MClassType */;
4995 val* var2 /* : MClassType */;
4996 short int var3 /* : Bool */;
4997 short int var4 /* : Bool */;
4998 {
4999 ((void(*)(val* self))(self->class->vft[COLOR_nit___nit__RapidTypeVisitor___standard__kernel__Object__init]))(self); /* init on <self:RapidTypeVisitor>*/
5000 }
5001 {
5002 { /* Inline rapid_type_analysis#RapidTypeVisitor#receiver (self) on <self:RapidTypeVisitor> */
5003 var2 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___receiver].val; /* _receiver on <self:RapidTypeVisitor> */
5004 if (unlikely(var2 == NULL)) {
5005 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _receiver");
5006 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 448);
5007 fatal_exit(1);
5008 }
5009 var = var2;
5010 RET_LABEL1:(void)0;
5011 }
5012 }
5013 {
5014 var3 = ((short int(*)(val* self))(var->class->vft[COLOR_nit__model__MType__need_anchor]))(var); /* need_anchor on <var:MClassType>*/
5015 }
5016 var4 = !var3;
5017 if (unlikely(!var4)) {
5018 PRINT_ERROR("Runtime error: %s", "Assert failed");
5019 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 453);
5020 fatal_exit(1);
5021 }
5022 RET_LABEL:;
5023 }
5024 /* method rapid_type_analysis#RapidTypeVisitor#visit for (self: RapidTypeVisitor, ANode) */
5025 void nit___nit__RapidTypeVisitor___nit__parser_nodes__Visitor__visit(val* self, val* p0) {
5026 val* var_n /* var n: ANode */;
5027 short int var /* : Bool */;
5028 int cltype;
5029 int idtype;
5030 short int var1 /* : Bool */;
5031 val* var2 /* : nullable MType */;
5032 short int var3 /* : Bool */;
5033 short int var4 /* : Bool */;
5034 val* var_other /* var other: nullable Object */;
5035 short int var6 /* : Bool */;
5036 short int var7 /* : Bool */;
5037 short int var_ /* var : Bool */;
5038 short int var8 /* : Bool */;
5039 short int var10 /* : Bool */;
5040 val* var11 /* : nullable MType */;
5041 val* var13 /* : nullable MType */;
5042 val* var_implicit_cast_to /* var implicit_cast_to: nullable MType */;
5043 short int var14 /* : Bool */;
5044 short int var15 /* : Bool */;
5045 short int var17 /* : Bool */;
5046 short int var18 /* : Bool */;
5047 short int var19 /* : Bool */;
5048 int cltype20;
5049 int idtype21;
5050 short int var22 /* : Bool */;
5051 var_n = p0;
5052 /* <var_n:ANode> isa AExpr */
5053 cltype = type_nit__AExpr.color;
5054 idtype = type_nit__AExpr.id;
5055 if(cltype >= var_n->type->table_size) {
5056 var = 0;
5057 } else {
5058 var = var_n->type->type_table[cltype] == idtype;
5059 }
5060 if (var){
5061 {
5062 var2 = ((val*(*)(val* self))(var_n->class->vft[COLOR_nit__typing__AExpr__mtype]))(var_n); /* mtype on <var_n:ANode(AExpr)>*/
5063 }
5064 if (var2 == NULL) {
5065 var3 = 0; /* is null */
5066 } else {
5067 var3 = 1; /* arg is null and recv is not */
5068 }
5069 if (0) {
5070 { /* Inline kernel#Object#!= (var2,((val*)NULL)) on <var2:nullable MType> */
5071 var_other = ((val*)NULL);
5072 {
5073 var6 = ((short int(*)(val* self, val* p0))(var2->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var2, var_other); /* == on <var2:nullable MType(MType)>*/
5074 }
5075 var7 = !var6;
5076 var4 = var7;
5077 goto RET_LABEL5;
5078 RET_LABEL5:(void)0;
5079 }
5080 var3 = var4;
5081 }
5082 var_ = var3;
5083 if (var3){
5084 var1 = var_;
5085 } else {
5086 {
5087 { /* Inline typing#AExpr#is_typed (var_n) on <var_n:ANode(AExpr)> */
5088 var10 = var_n->attrs[COLOR_nit__typing__AExpr___is_typed].s; /* _is_typed on <var_n:ANode(AExpr)> */
5089 var8 = var10;
5090 RET_LABEL9:(void)0;
5091 }
5092 }
5093 var1 = var8;
5094 }
5095 if (var1){
5096 {
5097 ((void(*)(val* self, val* p0))(var_n->class->vft[COLOR_nit__rapid_type_analysis__ANode__accept_rapid_type_visitor]))(var_n, self); /* accept_rapid_type_visitor on <var_n:ANode(AExpr)>*/
5098 }
5099 {
5100 { /* Inline typing#AExpr#implicit_cast_to (var_n) on <var_n:ANode(AExpr)> */
5101 var13 = var_n->attrs[COLOR_nit__typing__AExpr___implicit_cast_to].val; /* _implicit_cast_to on <var_n:ANode(AExpr)> */
5102 var11 = var13;
5103 RET_LABEL12:(void)0;
5104 }
5105 }
5106 var_implicit_cast_to = var11;
5107 if (var_implicit_cast_to == NULL) {
5108 var14 = 0; /* is null */
5109 } else {
5110 var14 = 1; /* arg is null and recv is not */
5111 }
5112 if (0) {
5113 { /* Inline kernel#Object#!= (var_implicit_cast_to,((val*)NULL)) on <var_implicit_cast_to:nullable MType> */
5114 var_other = ((val*)NULL);
5115 {
5116 var17 = ((short int(*)(val* self, val* p0))(var_implicit_cast_to->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_implicit_cast_to, var_other); /* == on <var_implicit_cast_to:nullable MType(MType)>*/
5117 }
5118 var18 = !var17;
5119 var15 = var18;
5120 goto RET_LABEL16;
5121 RET_LABEL16:(void)0;
5122 }
5123 var14 = var15;
5124 }
5125 if (var14){
5126 {
5127 nit___nit__RapidTypeVisitor___add_cast_type(self, var_implicit_cast_to); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_cast_type on <self:RapidTypeVisitor>*/
5128 }
5129 } else {
5130 }
5131 } else {
5132 }
5133 } else {
5134 {
5135 ((void(*)(val* self, val* p0))(var_n->class->vft[COLOR_nit__rapid_type_analysis__ANode__accept_rapid_type_visitor]))(var_n, self); /* accept_rapid_type_visitor on <var_n:ANode>*/
5136 }
5137 }
5138 /* <var_n:ANode> isa AAnnotations */
5139 cltype20 = type_nit__AAnnotations.color;
5140 idtype21 = type_nit__AAnnotations.id;
5141 if(cltype20 >= var_n->type->table_size) {
5142 var19 = 0;
5143 } else {
5144 var19 = var_n->type->type_table[cltype20] == idtype21;
5145 }
5146 var22 = !var19;
5147 if (var22){
5148 {
5149 ((void(*)(val* self, val* p0))(var_n->class->vft[COLOR_nit__parser_nodes__ANode__visit_all]))(var_n, self); /* visit_all on <var_n:ANode>*/
5150 }
5151 } else {
5152 }
5153 RET_LABEL:;
5154 }
5155 /* method rapid_type_analysis#RapidTypeVisitor#cleanup_type for (self: RapidTypeVisitor, MType): nullable MClassType */
5156 val* nit___nit__RapidTypeVisitor___cleanup_type(val* self, val* p0) {
5157 val* var /* : nullable MClassType */;
5158 val* var_mtype /* var mtype: MType */;
5159 val* var1 /* : RapidTypeAnalysis */;
5160 val* var3 /* : RapidTypeAnalysis */;
5161 val* var4 /* : MModule */;
5162 val* var6 /* : MModule */;
5163 val* var7 /* : MClassType */;
5164 val* var9 /* : MClassType */;
5165 val* var10 /* : MType */;
5166 short int var11 /* : Bool */;
5167 int cltype;
5168 int idtype;
5169 val* var12 /* : MType */;
5170 short int var13 /* : Bool */;
5171 int cltype14;
5172 int idtype15;
5173 short int var16 /* : Bool */;
5174 short int var17 /* : Bool */;
5175 var_mtype = p0;
5176 {
5177 { /* Inline rapid_type_analysis#RapidTypeVisitor#analysis (self) on <self:RapidTypeVisitor> */
5178 var3 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <self:RapidTypeVisitor> */
5179 if (unlikely(var3 == NULL)) {
5180 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
5181 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 447);
5182 fatal_exit(1);
5183 }
5184 var1 = var3;
5185 RET_LABEL2:(void)0;
5186 }
5187 }
5188 {
5189 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (var1) on <var1:RapidTypeAnalysis> */
5190 var6 = var1->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <var1:RapidTypeAnalysis> */
5191 if (unlikely(var6 == NULL)) {
5192 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
5193 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
5194 fatal_exit(1);
5195 }
5196 var4 = var6;
5197 RET_LABEL5:(void)0;
5198 }
5199 }
5200 {
5201 { /* Inline rapid_type_analysis#RapidTypeVisitor#receiver (self) on <self:RapidTypeVisitor> */
5202 var9 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___receiver].val; /* _receiver on <self:RapidTypeVisitor> */
5203 if (unlikely(var9 == NULL)) {
5204 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _receiver");
5205 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 448);
5206 fatal_exit(1);
5207 }
5208 var7 = var9;
5209 RET_LABEL8:(void)0;
5210 }
5211 }
5212 {
5213 var10 = ((val*(*)(val* self, val* p0, val* p1))(var_mtype->class->vft[COLOR_nit__model__MType__anchor_to]))(var_mtype, var4, var7); /* anchor_to on <var_mtype:MType>*/
5214 }
5215 var_mtype = var10;
5216 /* <var_mtype:MType> isa MNullType */
5217 cltype = type_nit__MNullType.color;
5218 idtype = type_nit__MNullType.id;
5219 if(cltype >= var_mtype->type->table_size) {
5220 var11 = 0;
5221 } else {
5222 var11 = var_mtype->type->type_table[cltype] == idtype;
5223 }
5224 if (var11){
5225 var = ((val*)NULL);
5226 goto RET_LABEL;
5227 } else {
5228 }
5229 {
5230 var12 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nit__model__MType__undecorate]))(var_mtype); /* undecorate on <var_mtype:MType>*/
5231 }
5232 var_mtype = var12;
5233 /* <var_mtype:MType> isa MClassType */
5234 cltype14 = type_nit__MClassType.color;
5235 idtype15 = type_nit__MClassType.id;
5236 if(cltype14 >= var_mtype->type->table_size) {
5237 var13 = 0;
5238 } else {
5239 var13 = var_mtype->type->type_table[cltype14] == idtype15;
5240 }
5241 if (unlikely(!var13)) {
5242 PRINT_ERROR("Runtime error: %s", "Assert failed");
5243 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 479);
5244 fatal_exit(1);
5245 }
5246 {
5247 var16 = ((short int(*)(val* self))(var_mtype->class->vft[COLOR_nit__model__MType__need_anchor]))(var_mtype); /* need_anchor on <var_mtype:MType(MClassType)>*/
5248 }
5249 var17 = !var16;
5250 if (unlikely(!var17)) {
5251 PRINT_ERROR("Runtime error: %s", "Assert failed");
5252 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 480);
5253 fatal_exit(1);
5254 }
5255 var = var_mtype;
5256 goto RET_LABEL;
5257 RET_LABEL:;
5258 return var;
5259 }
5260 /* method rapid_type_analysis#RapidTypeVisitor#get_method for (self: RapidTypeVisitor, MType, String): MMethod */
5261 val* nit___nit__RapidTypeVisitor___get_method(val* self, val* p0, val* p1) {
5262 val* var /* : MMethod */;
5263 val* var_recv /* var recv: MType */;
5264 val* var_name /* var name: String */;
5265 val* var1 /* : nullable MClassType */;
5266 val* var_mtype /* var mtype: nullable MClassType */;
5267 short int var2 /* : Bool */;
5268 short int var3 /* : Bool */;
5269 val* var_other /* var other: nullable Object */;
5270 short int var5 /* : Bool */;
5271 short int var6 /* : Bool */;
5272 val* var7 /* : RapidTypeAnalysis */;
5273 val* var9 /* : RapidTypeAnalysis */;
5274 val* var10 /* : ModelBuilder */;
5275 val* var12 /* : ModelBuilder */;
5276 val* var13 /* : nullable ANode */;
5277 val* var15 /* : nullable ANode */;
5278 val* var16 /* : MClass */;
5279 val* var18 /* : MClass */;
5280 val* var19 /* : RapidTypeAnalysis */;
5281 val* var21 /* : RapidTypeAnalysis */;
5282 val* var22 /* : MModule */;
5283 val* var24 /* : MModule */;
5284 val* var25 /* : MMethod */;
5285 var_recv = p0;
5286 var_name = p1;
5287 {
5288 var1 = nit___nit__RapidTypeVisitor___cleanup_type(self, var_recv);
5289 }
5290 var_mtype = var1;
5291 if (var_mtype == NULL) {
5292 var2 = 0; /* is null */
5293 } else {
5294 var2 = 1; /* arg is null and recv is not */
5295 }
5296 if (0) {
5297 { /* Inline kernel#Object#!= (var_mtype,((val*)NULL)) on <var_mtype:nullable MClassType> */
5298 var_other = ((val*)NULL);
5299 {
5300 var5 = ((short int(*)(val* self, val* p0))(var_mtype->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_mtype, var_other); /* == on <var_mtype:nullable MClassType(MClassType)>*/
5301 }
5302 var6 = !var5;
5303 var3 = var6;
5304 goto RET_LABEL4;
5305 RET_LABEL4:(void)0;
5306 }
5307 var2 = var3;
5308 }
5309 if (unlikely(!var2)) {
5310 PRINT_ERROR("Runtime error: %s", "Assert failed");
5311 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 487);
5312 fatal_exit(1);
5313 }
5314 {
5315 { /* Inline rapid_type_analysis#RapidTypeVisitor#analysis (self) on <self:RapidTypeVisitor> */
5316 var9 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <self:RapidTypeVisitor> */
5317 if (unlikely(var9 == NULL)) {
5318 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
5319 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 447);
5320 fatal_exit(1);
5321 }
5322 var7 = var9;
5323 RET_LABEL8:(void)0;
5324 }
5325 }
5326 {
5327 { /* Inline rapid_type_analysis#RapidTypeAnalysis#modelbuilder (var7) on <var7:RapidTypeAnalysis> */
5328 var12 = var7->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___modelbuilder].val; /* _modelbuilder on <var7:RapidTypeAnalysis> */
5329 if (unlikely(var12 == NULL)) {
5330 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder");
5331 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 53);
5332 fatal_exit(1);
5333 }
5334 var10 = var12;
5335 RET_LABEL11:(void)0;
5336 }
5337 }
5338 {
5339 { /* Inline parser_nodes#Visitor#current_node (self) on <self:RapidTypeVisitor> */
5340 var15 = self->attrs[COLOR_nit__parser_nodes__Visitor___current_node].val; /* _current_node on <self:RapidTypeVisitor> */
5341 var13 = var15;
5342 RET_LABEL14:(void)0;
5343 }
5344 }
5345 if (unlikely(var13 == NULL)) {
5346 PRINT_ERROR("Runtime error: %s", "Cast failed");
5347 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 488);
5348 fatal_exit(1);
5349 }
5350 {
5351 { /* Inline model#MClassType#mclass (var_mtype) on <var_mtype:nullable MClassType(MClassType)> */
5352 var18 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on <var_mtype:nullable MClassType(MClassType)> */
5353 if (unlikely(var18 == NULL)) {
5354 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
5355 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138);
5356 fatal_exit(1);
5357 }
5358 var16 = var18;
5359 RET_LABEL17:(void)0;
5360 }
5361 }
5362 {
5363 { /* Inline rapid_type_analysis#RapidTypeVisitor#analysis (self) on <self:RapidTypeVisitor> */
5364 var21 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <self:RapidTypeVisitor> */
5365 if (unlikely(var21 == NULL)) {
5366 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
5367 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 447);
5368 fatal_exit(1);
5369 }
5370 var19 = var21;
5371 RET_LABEL20:(void)0;
5372 }
5373 }
5374 {
5375 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (var19) on <var19:RapidTypeAnalysis> */
5376 var24 = var19->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <var19:RapidTypeAnalysis> */
5377 if (unlikely(var24 == NULL)) {
5378 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
5379 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
5380 fatal_exit(1);
5381 }
5382 var22 = var24;
5383 RET_LABEL23:(void)0;
5384 }
5385 }
5386 {
5387 var25 = nit___nit__ModelBuilder___force_get_primitive_method(var10, var13, var_name, var16, var22);
5388 }
5389 var = var25;
5390 goto RET_LABEL;
5391 RET_LABEL:;
5392 return var;
5393 }
5394 /* method rapid_type_analysis#RapidTypeVisitor#add_type for (self: RapidTypeVisitor, MClassType) */
5395 void nit___nit__RapidTypeVisitor___add_type(val* self, val* p0) {
5396 val* var_mtype /* var mtype: MClassType */;
5397 val* var /* : RapidTypeAnalysis */;
5398 val* var2 /* : RapidTypeAnalysis */;
5399 val* var3 /* : MClassType */;
5400 val* var5 /* : MClassType */;
5401 var_mtype = p0;
5402 {
5403 { /* Inline rapid_type_analysis#RapidTypeVisitor#analysis (self) on <self:RapidTypeVisitor> */
5404 var2 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <self:RapidTypeVisitor> */
5405 if (unlikely(var2 == NULL)) {
5406 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
5407 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 447);
5408 fatal_exit(1);
5409 }
5410 var = var2;
5411 RET_LABEL1:(void)0;
5412 }
5413 }
5414 {
5415 { /* Inline rapid_type_analysis#RapidTypeVisitor#receiver (self) on <self:RapidTypeVisitor> */
5416 var5 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___receiver].val; /* _receiver on <self:RapidTypeVisitor> */
5417 if (unlikely(var5 == NULL)) {
5418 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _receiver");
5419 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 448);
5420 fatal_exit(1);
5421 }
5422 var3 = var5;
5423 RET_LABEL4:(void)0;
5424 }
5425 }
5426 {
5427 nit___nit__RapidTypeAnalysis___add_new(var, var3, var_mtype); /* Direct call rapid_type_analysis#RapidTypeAnalysis#add_new on <var:RapidTypeAnalysis>*/
5428 }
5429 RET_LABEL:;
5430 }
5431 /* method rapid_type_analysis#RapidTypeVisitor#add_monomorphic_send for (self: RapidTypeVisitor, MType, MMethod) */
5432 void nit___nit__RapidTypeVisitor___add_monomorphic_send(val* self, val* p0, val* p1) {
5433 val* var_mtype /* var mtype: MType */;
5434 val* var_mproperty /* var mproperty: MMethod */;
5435 val* var /* : RapidTypeAnalysis */;
5436 val* var2 /* : RapidTypeAnalysis */;
5437 val* var3 /* : HashSet[MMethod] */;
5438 val* var5 /* : HashSet[MMethod] */;
5439 val* var6 /* : RapidTypeAnalysis */;
5440 val* var8 /* : RapidTypeAnalysis */;
5441 short int var9 /* : Bool */;
5442 int cltype;
5443 int idtype;
5444 const char* var_class_name;
5445 var_mtype = p0;
5446 var_mproperty = p1;
5447 {
5448 { /* Inline rapid_type_analysis#RapidTypeVisitor#analysis (self) on <self:RapidTypeVisitor> */
5449 var2 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <self:RapidTypeVisitor> */
5450 if (unlikely(var2 == NULL)) {
5451 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
5452 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 447);
5453 fatal_exit(1);
5454 }
5455 var = var2;
5456 RET_LABEL1:(void)0;
5457 }
5458 }
5459 {
5460 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_methods (var) on <var:RapidTypeAnalysis> */
5461 var5 = var->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_methods].val; /* _live_methods on <var:RapidTypeAnalysis> */
5462 if (unlikely(var5 == NULL)) {
5463 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_methods");
5464 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 82);
5465 fatal_exit(1);
5466 }
5467 var3 = var5;
5468 RET_LABEL4:(void)0;
5469 }
5470 }
5471 {
5472 standard___standard__HashSet___standard__abstract_collection__SimpleCollection__add(var3, var_mproperty); /* Direct call hash_collection#HashSet#add on <var3:HashSet[MMethod]>*/
5473 }
5474 {
5475 { /* Inline rapid_type_analysis#RapidTypeVisitor#analysis (self) on <self:RapidTypeVisitor> */
5476 var8 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <self:RapidTypeVisitor> */
5477 if (unlikely(var8 == NULL)) {
5478 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
5479 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 447);
5480 fatal_exit(1);
5481 }
5482 var6 = var8;
5483 RET_LABEL7:(void)0;
5484 }
5485 }
5486 /* <var_mtype:MType> isa MClassType */
5487 cltype = type_nit__MClassType.color;
5488 idtype = type_nit__MClassType.id;
5489 if(cltype >= var_mtype->type->table_size) {
5490 var9 = 0;
5491 } else {
5492 var9 = var_mtype->type->type_table[cltype] == idtype;
5493 }
5494 if (unlikely(!var9)) {
5495 var_class_name = var_mtype == NULL ? "null" : var_mtype->type->name;
5496 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
5497 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 496);
5498 fatal_exit(1);
5499 }
5500 {
5501 nit___nit__RapidTypeAnalysis___try_send(var6, var_mtype, var_mproperty); /* Direct call rapid_type_analysis#RapidTypeAnalysis#try_send on <var6:RapidTypeAnalysis>*/
5502 }
5503 RET_LABEL:;
5504 }
5505 /* method rapid_type_analysis#RapidTypeVisitor#add_cast_type for (self: RapidTypeVisitor, MType) */
5506 void nit___nit__RapidTypeVisitor___add_cast_type(val* self, val* p0) {
5507 val* var_mtype /* var mtype: MType */;
5508 val* var /* : RapidTypeAnalysis */;
5509 val* var2 /* : RapidTypeAnalysis */;
5510 var_mtype = p0;
5511 {
5512 { /* Inline rapid_type_analysis#RapidTypeVisitor#analysis (self) on <self:RapidTypeVisitor> */
5513 var2 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <self:RapidTypeVisitor> */
5514 if (unlikely(var2 == NULL)) {
5515 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
5516 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 447);
5517 fatal_exit(1);
5518 }
5519 var = var2;
5520 RET_LABEL1:(void)0;
5521 }
5522 }
5523 {
5524 nit___nit__RapidTypeAnalysis___add_cast(var, var_mtype); /* Direct call rapid_type_analysis#RapidTypeAnalysis#add_cast on <var:RapidTypeAnalysis>*/
5525 }
5526 RET_LABEL:;
5527 }
5528 /* method rapid_type_analysis#RapidTypeVisitor#add_callsite for (self: RapidTypeVisitor, nullable CallSite) */
5529 void nit___nit__RapidTypeVisitor___add_callsite(val* self, val* p0) {
5530 val* var_callsite /* var callsite: nullable CallSite */;
5531 short int var /* : Bool */;
5532 short int var1 /* : Bool */;
5533 val* var_other /* var other: nullable Object */;
5534 short int var3 /* : Bool */;
5535 short int var4 /* : Bool */;
5536 val* var5 /* : MMethodDef */;
5537 val* var7 /* : MMethodDef */;
5538 val* var8 /* : Array[MProperty] */;
5539 val* var10 /* : Array[MProperty] */;
5540 val* var_ /* var : Array[MProperty] */;
5541 val* var11 /* : ArrayIterator[nullable Object] */;
5542 val* var_12 /* var : ArrayIterator[MProperty] */;
5543 short int var13 /* : Bool */;
5544 val* var14 /* : nullable Object */;
5545 val* var_m /* var m: MProperty */;
5546 short int var15 /* : Bool */;
5547 int cltype;
5548 int idtype;
5549 val* var16 /* : RapidTypeAnalysis */;
5550 val* var18 /* : RapidTypeAnalysis */;
5551 val* var19 /* : MType */;
5552 val* var21 /* : MType */;
5553 val* var22 /* : RapidTypeAnalysis */;
5554 val* var24 /* : RapidTypeAnalysis */;
5555 val* var25 /* : MType */;
5556 val* var27 /* : MType */;
5557 val* var28 /* : MMethod */;
5558 val* var30 /* : MMethod */;
5559 val* var31 /* : RapidTypeAnalysis */;
5560 val* var33 /* : RapidTypeAnalysis */;
5561 val* var34 /* : HashSet[CallSite] */;
5562 val* var36 /* : HashSet[CallSite] */;
5563 var_callsite = p0;
5564 if (var_callsite == NULL) {
5565 var = 0; /* is null */
5566 } else {
5567 var = 1; /* arg is null and recv is not */
5568 }
5569 if (0) {
5570 { /* Inline kernel#Object#!= (var_callsite,((val*)NULL)) on <var_callsite:nullable CallSite> */
5571 var_other = ((val*)NULL);
5572 {
5573 var3 = ((short int(*)(val* self, val* p0))(var_callsite->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_callsite, var_other); /* == on <var_callsite:nullable CallSite(CallSite)>*/
5574 }
5575 var4 = !var3;
5576 var1 = var4;
5577 goto RET_LABEL2;
5578 RET_LABEL2:(void)0;
5579 }
5580 var = var1;
5581 }
5582 if (var){
5583 {
5584 { /* Inline typing#CallSite#mpropdef (var_callsite) on <var_callsite:nullable CallSite(CallSite)> */
5585 var7 = var_callsite->attrs[COLOR_nit__typing__CallSite___mpropdef].val; /* _mpropdef on <var_callsite:nullable CallSite(CallSite)> */
5586 if (unlikely(var7 == NULL)) {
5587 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdef");
5588 PRINT_ERROR(" (%s:%d)\n", FILE_nit__typing, 627);
5589 fatal_exit(1);
5590 }
5591 var5 = var7;
5592 RET_LABEL6:(void)0;
5593 }
5594 }
5595 {
5596 { /* Inline model#MMethodDef#initializers (var5) on <var5:MMethodDef> */
5597 var10 = var5->attrs[COLOR_nit__model__MMethodDef___initializers].val; /* _initializers on <var5:MMethodDef> */
5598 if (unlikely(var10 == NULL)) {
5599 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _initializers");
5600 PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2345);
5601 fatal_exit(1);
5602 }
5603 var8 = var10;
5604 RET_LABEL9:(void)0;
5605 }
5606 }
5607 var_ = var8;
5608 {
5609 var11 = standard___standard__AbstractArrayRead___standard__abstract_collection__Collection__iterator(var_);
5610 }
5611 var_12 = var11;
5612 for(;;) {
5613 {
5614 var13 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__is_ok(var_12);
5615 }
5616 if (var13){
5617 {
5618 var14 = standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__item(var_12);
5619 }
5620 var_m = var14;
5621 /* <var_m:MProperty> isa MMethod */
5622 cltype = type_nit__MMethod.color;
5623 idtype = type_nit__MMethod.id;
5624 if(cltype >= var_m->type->table_size) {
5625 var15 = 0;
5626 } else {
5627 var15 = var_m->type->type_table[cltype] == idtype;
5628 }
5629 if (var15){
5630 {
5631 { /* Inline rapid_type_analysis#RapidTypeVisitor#analysis (self) on <self:RapidTypeVisitor> */
5632 var18 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <self:RapidTypeVisitor> */
5633 if (unlikely(var18 == NULL)) {
5634 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
5635 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 447);
5636 fatal_exit(1);
5637 }
5638 var16 = var18;
5639 RET_LABEL17:(void)0;
5640 }
5641 }
5642 {
5643 { /* Inline typing#CallSite#recv (var_callsite) on <var_callsite:nullable CallSite(CallSite)> */
5644 var21 = var_callsite->attrs[COLOR_nit__typing__CallSite___recv].val; /* _recv on <var_callsite:nullable CallSite(CallSite)> */
5645 if (unlikely(var21 == NULL)) {
5646 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _recv");
5647 PRINT_ERROR(" (%s:%d)\n", FILE_nit__typing, 610);
5648 fatal_exit(1);
5649 }
5650 var19 = var21;
5651 RET_LABEL20:(void)0;
5652 }
5653 }
5654 {
5655 nit___nit__RapidTypeAnalysis___add_send(var16, var19, var_m); /* Direct call rapid_type_analysis#RapidTypeAnalysis#add_send on <var16:RapidTypeAnalysis>*/
5656 }
5657 } else {
5658 }
5659 {
5660 standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__next(var_12); /* Direct call array#ArrayIterator#next on <var_12:ArrayIterator[MProperty]>*/
5661 }
5662 } else {
5663 goto BREAK_label;
5664 }
5665 }
5666 BREAK_label: (void)0;
5667 {
5668 standard__array___standard__array__ArrayIterator___standard__abstract_collection__Iterator__finish(var_12); /* Direct call array#ArrayIterator#finish on <var_12:ArrayIterator[MProperty]>*/
5669 }
5670 {
5671 { /* Inline rapid_type_analysis#RapidTypeVisitor#analysis (self) on <self:RapidTypeVisitor> */
5672 var24 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <self:RapidTypeVisitor> */
5673 if (unlikely(var24 == NULL)) {
5674 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
5675 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 447);
5676 fatal_exit(1);
5677 }
5678 var22 = var24;
5679 RET_LABEL23:(void)0;
5680 }
5681 }
5682 {
5683 { /* Inline typing#CallSite#recv (var_callsite) on <var_callsite:nullable CallSite(CallSite)> */
5684 var27 = var_callsite->attrs[COLOR_nit__typing__CallSite___recv].val; /* _recv on <var_callsite:nullable CallSite(CallSite)> */
5685 if (unlikely(var27 == NULL)) {
5686 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _recv");
5687 PRINT_ERROR(" (%s:%d)\n", FILE_nit__typing, 610);
5688 fatal_exit(1);
5689 }
5690 var25 = var27;
5691 RET_LABEL26:(void)0;
5692 }
5693 }
5694 {
5695 { /* Inline typing#CallSite#mproperty (var_callsite) on <var_callsite:nullable CallSite(CallSite)> */
5696 var30 = var_callsite->attrs[COLOR_nit__typing__CallSite___mproperty].val; /* _mproperty on <var_callsite:nullable CallSite(CallSite)> */
5697 if (unlikely(var30 == NULL)) {
5698 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mproperty");
5699 PRINT_ERROR(" (%s:%d)\n", FILE_nit__typing, 624);
5700 fatal_exit(1);
5701 }
5702 var28 = var30;
5703 RET_LABEL29:(void)0;
5704 }
5705 }
5706 {
5707 nit___nit__RapidTypeAnalysis___add_send(var22, var25, var28); /* Direct call rapid_type_analysis#RapidTypeAnalysis#add_send on <var22:RapidTypeAnalysis>*/
5708 }
5709 {
5710 { /* Inline rapid_type_analysis#RapidTypeVisitor#analysis (self) on <self:RapidTypeVisitor> */
5711 var33 = self->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <self:RapidTypeVisitor> */
5712 if (unlikely(var33 == NULL)) {
5713 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
5714 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 447);
5715 fatal_exit(1);
5716 }
5717 var31 = var33;
5718 RET_LABEL32:(void)0;
5719 }
5720 }
5721 {
5722 { /* Inline rapid_type_analysis#RapidTypeAnalysis#live_callsites (var31) on <var31:RapidTypeAnalysis> */
5723 var36 = var31->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_callsites].val; /* _live_callsites on <var31:RapidTypeAnalysis> */
5724 if (unlikely(var36 == NULL)) {
5725 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_callsites");
5726 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 85);
5727 fatal_exit(1);
5728 }
5729 var34 = var36;
5730 RET_LABEL35:(void)0;
5731 }
5732 }
5733 {
5734 standard___standard__HashSet___standard__abstract_collection__SimpleCollection__add(var34, var_callsite); /* Direct call hash_collection#HashSet#add on <var34:HashSet[CallSite]>*/
5735 }
5736 } else {
5737 }
5738 RET_LABEL:;
5739 }
5740 /* method rapid_type_analysis#ANode#accept_rapid_type_visitor for (self: ANode, RapidTypeVisitor) */
5741 void nit__rapid_type_analysis___ANode___accept_rapid_type_visitor(val* self, val* p0) {
5742 val* var_v /* var v: RapidTypeVisitor */;
5743 var_v = p0;
5744 RET_LABEL:;
5745 }
5746 /* method rapid_type_analysis#AIntExpr#accept_rapid_type_visitor for (self: AIntExpr, RapidTypeVisitor) */
5747 void nit__rapid_type_analysis___AIntExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
5748 val* var_v /* var v: RapidTypeVisitor */;
5749 val* var /* : nullable MType */;
5750 val* var2 /* : nullable MType */;
5751 short int var3 /* : Bool */;
5752 int cltype;
5753 int idtype;
5754 const char* var_class_name;
5755 var_v = p0;
5756 {
5757 { /* Inline typing#AExpr#mtype (self) on <self:AIntExpr> */
5758 var2 = self->attrs[COLOR_nit__typing__AExpr___mtype].val; /* _mtype on <self:AIntExpr> */
5759 var = var2;
5760 RET_LABEL1:(void)0;
5761 }
5762 }
5763 /* <var:nullable MType> isa MClassType */
5764 cltype = type_nit__MClassType.color;
5765 idtype = type_nit__MClassType.id;
5766 if(var == NULL) {
5767 var3 = 0;
5768 } else {
5769 if(cltype >= var->type->table_size) {
5770 var3 = 0;
5771 } else {
5772 var3 = var->type->type_table[cltype] == idtype;
5773 }
5774 }
5775 if (unlikely(!var3)) {
5776 var_class_name = var == NULL ? "null" : var->type->name;
5777 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
5778 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 525);
5779 fatal_exit(1);
5780 }
5781 {
5782 nit___nit__RapidTypeVisitor___add_type(var_v, var); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_type on <var_v:RapidTypeVisitor>*/
5783 }
5784 RET_LABEL:;
5785 }
5786 /* method rapid_type_analysis#AByteExpr#accept_rapid_type_visitor for (self: AByteExpr, RapidTypeVisitor) */
5787 void nit__rapid_type_analysis___AByteExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
5788 val* var_v /* var v: RapidTypeVisitor */;
5789 val* var /* : nullable MType */;
5790 val* var2 /* : nullable MType */;
5791 short int var3 /* : Bool */;
5792 int cltype;
5793 int idtype;
5794 const char* var_class_name;
5795 var_v = p0;
5796 {
5797 { /* Inline typing#AExpr#mtype (self) on <self:AByteExpr> */
5798 var2 = self->attrs[COLOR_nit__typing__AExpr___mtype].val; /* _mtype on <self:AByteExpr> */
5799 var = var2;
5800 RET_LABEL1:(void)0;
5801 }
5802 }
5803 /* <var:nullable MType> isa MClassType */
5804 cltype = type_nit__MClassType.color;
5805 idtype = type_nit__MClassType.id;
5806 if(var == NULL) {
5807 var3 = 0;
5808 } else {
5809 if(cltype >= var->type->table_size) {
5810 var3 = 0;
5811 } else {
5812 var3 = var->type->type_table[cltype] == idtype;
5813 }
5814 }
5815 if (unlikely(!var3)) {
5816 var_class_name = var == NULL ? "null" : var->type->name;
5817 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
5818 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 532);
5819 fatal_exit(1);
5820 }
5821 {
5822 nit___nit__RapidTypeVisitor___add_type(var_v, var); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_type on <var_v:RapidTypeVisitor>*/
5823 }
5824 RET_LABEL:;
5825 }
5826 /* method rapid_type_analysis#AFloatExpr#accept_rapid_type_visitor for (self: AFloatExpr, RapidTypeVisitor) */
5827 void nit__rapid_type_analysis___AFloatExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
5828 val* var_v /* var v: RapidTypeVisitor */;
5829 val* var /* : nullable MType */;
5830 val* var2 /* : nullable MType */;
5831 short int var3 /* : Bool */;
5832 int cltype;
5833 int idtype;
5834 const char* var_class_name;
5835 var_v = p0;
5836 {
5837 { /* Inline typing#AExpr#mtype (self) on <self:AFloatExpr> */
5838 var2 = self->attrs[COLOR_nit__typing__AExpr___mtype].val; /* _mtype on <self:AFloatExpr> */
5839 var = var2;
5840 RET_LABEL1:(void)0;
5841 }
5842 }
5843 /* <var:nullable MType> isa MClassType */
5844 cltype = type_nit__MClassType.color;
5845 idtype = type_nit__MClassType.id;
5846 if(var == NULL) {
5847 var3 = 0;
5848 } else {
5849 if(cltype >= var->type->table_size) {
5850 var3 = 0;
5851 } else {
5852 var3 = var->type->type_table[cltype] == idtype;
5853 }
5854 }
5855 if (unlikely(!var3)) {
5856 var_class_name = var == NULL ? "null" : var->type->name;
5857 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
5858 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 539);
5859 fatal_exit(1);
5860 }
5861 {
5862 nit___nit__RapidTypeVisitor___add_type(var_v, var); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_type on <var_v:RapidTypeVisitor>*/
5863 }
5864 RET_LABEL:;
5865 }
5866 /* method rapid_type_analysis#ACharExpr#accept_rapid_type_visitor for (self: ACharExpr, RapidTypeVisitor) */
5867 void nit__rapid_type_analysis___ACharExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
5868 val* var_v /* var v: RapidTypeVisitor */;
5869 val* var /* : nullable MType */;
5870 val* var2 /* : nullable MType */;
5871 short int var3 /* : Bool */;
5872 int cltype;
5873 int idtype;
5874 const char* var_class_name;
5875 var_v = p0;
5876 {
5877 { /* Inline typing#AExpr#mtype (self) on <self:ACharExpr> */
5878 var2 = self->attrs[COLOR_nit__typing__AExpr___mtype].val; /* _mtype on <self:ACharExpr> */
5879 var = var2;
5880 RET_LABEL1:(void)0;
5881 }
5882 }
5883 /* <var:nullable MType> isa MClassType */
5884 cltype = type_nit__MClassType.color;
5885 idtype = type_nit__MClassType.id;
5886 if(var == NULL) {
5887 var3 = 0;
5888 } else {
5889 if(cltype >= var->type->table_size) {
5890 var3 = 0;
5891 } else {
5892 var3 = var->type->type_table[cltype] == idtype;
5893 }
5894 }
5895 if (unlikely(!var3)) {
5896 var_class_name = var == NULL ? "null" : var->type->name;
5897 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
5898 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 546);
5899 fatal_exit(1);
5900 }
5901 {
5902 nit___nit__RapidTypeVisitor___add_type(var_v, var); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_type on <var_v:RapidTypeVisitor>*/
5903 }
5904 RET_LABEL:;
5905 }
5906 /* method rapid_type_analysis#AArrayExpr#accept_rapid_type_visitor for (self: AArrayExpr, RapidTypeVisitor) */
5907 void nit__rapid_type_analysis___AArrayExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
5908 val* var_v /* var v: RapidTypeVisitor */;
5909 val* var /* : nullable MType */;
5910 val* var2 /* : nullable MType */;
5911 short int var3 /* : Bool */;
5912 int cltype;
5913 int idtype;
5914 const char* var_class_name;
5915 val* var_mtype /* var mtype: MClassType */;
5916 val* var4 /* : RapidTypeAnalysis */;
5917 val* var6 /* : RapidTypeAnalysis */;
5918 val* var7 /* : MModule */;
5919 val* var9 /* : MModule */;
5920 val* var10 /* : Array[MType] */;
5921 val* var11 /* : nullable Object */;
5922 val* var12 /* : MClassType */;
5923 val* var_native /* var native: MClassType */;
5924 val* var13 /* : nullable MClassType */;
5925 static val* varonce;
5926 val* var14 /* : String */;
5927 char* var15 /* : NativeString */;
5928 val* var16 /* : FlatString */;
5929 val* var17 /* : MMethod */;
5930 val* var_prop /* var prop: MMethod */;
5931 val* var18 /* : nullable CallSite */;
5932 val* var20 /* : nullable CallSite */;
5933 val* var21 /* : nullable CallSite */;
5934 val* var23 /* : nullable CallSite */;
5935 var_v = p0;
5936 {
5937 { /* Inline typing#AExpr#mtype (self) on <self:AArrayExpr> */
5938 var2 = self->attrs[COLOR_nit__typing__AExpr___mtype].val; /* _mtype on <self:AArrayExpr> */
5939 var = var2;
5940 RET_LABEL1:(void)0;
5941 }
5942 }
5943 /* <var:nullable MType> isa MClassType */
5944 cltype = type_nit__MClassType.color;
5945 idtype = type_nit__MClassType.id;
5946 if(var == NULL) {
5947 var3 = 0;
5948 } else {
5949 if(cltype >= var->type->table_size) {
5950 var3 = 0;
5951 } else {
5952 var3 = var->type->type_table[cltype] == idtype;
5953 }
5954 }
5955 if (unlikely(!var3)) {
5956 var_class_name = var == NULL ? "null" : var->type->name;
5957 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
5958 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 553);
5959 fatal_exit(1);
5960 }
5961 var_mtype = var;
5962 {
5963 nit___nit__RapidTypeVisitor___add_type(var_v, var_mtype); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_type on <var_v:RapidTypeVisitor>*/
5964 }
5965 {
5966 { /* Inline rapid_type_analysis#RapidTypeVisitor#analysis (var_v) on <var_v:RapidTypeVisitor> */
5967 var6 = var_v->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <var_v:RapidTypeVisitor> */
5968 if (unlikely(var6 == NULL)) {
5969 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
5970 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 447);
5971 fatal_exit(1);
5972 }
5973 var4 = var6;
5974 RET_LABEL5:(void)0;
5975 }
5976 }
5977 {
5978 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (var4) on <var4:RapidTypeAnalysis> */
5979 var9 = var4->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <var4:RapidTypeAnalysis> */
5980 if (unlikely(var9 == NULL)) {
5981 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
5982 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
5983 fatal_exit(1);
5984 }
5985 var7 = var9;
5986 RET_LABEL8:(void)0;
5987 }
5988 }
5989 {
5990 var10 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nit__model__MClassType__arguments]))(var_mtype); /* arguments on <var_mtype:MClassType>*/
5991 }
5992 {
5993 var11 = standard___standard__SequenceRead___Collection__first(var10);
5994 }
5995 {
5996 var12 = nit__model___MModule___native_array_type(var7, var11);
5997 }
5998 var_native = var12;
5999 {
6000 nit___nit__RapidTypeVisitor___add_type(var_v, var_native); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_type on <var_v:RapidTypeVisitor>*/
6001 }
6002 {
6003 var13 = nit___nit__RapidTypeVisitor___cleanup_type(var_v, var_mtype);
6004 }
6005 if (unlikely(var13 == NULL)) {
6006 PRINT_ERROR("Runtime error: %s", "Cast failed");
6007 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 557);
6008 fatal_exit(1);
6009 }
6010 var_mtype = var13;
6011 if (likely(varonce!=NULL)) {
6012 var14 = varonce;
6013 } else {
6014 var15 = "with_native";
6015 var16 = standard___standard__NativeString___to_s_with_length(var15, 11l);
6016 var14 = var16;
6017 varonce = var14;
6018 }
6019 {
6020 var17 = nit___nit__RapidTypeVisitor___get_method(var_v, var_mtype, var14);
6021 }
6022 var_prop = var17;
6023 {
6024 nit___nit__RapidTypeVisitor___add_monomorphic_send(var_v, var_mtype, var_prop); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_monomorphic_send on <var_v:RapidTypeVisitor>*/
6025 }
6026 {
6027 { /* Inline typing#AArrayExpr#with_capacity_callsite (self) on <self:AArrayExpr> */
6028 var20 = self->attrs[COLOR_nit__typing__AArrayExpr___with_capacity_callsite].val; /* _with_capacity_callsite on <self:AArrayExpr> */
6029 var18 = var20;
6030 RET_LABEL19:(void)0;
6031 }
6032 }
6033 {
6034 nit___nit__RapidTypeVisitor___add_callsite(var_v, var18); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_callsite on <var_v:RapidTypeVisitor>*/
6035 }
6036 {
6037 { /* Inline typing#AArrayExpr#push_callsite (self) on <self:AArrayExpr> */
6038 var23 = self->attrs[COLOR_nit__typing__AArrayExpr___push_callsite].val; /* _push_callsite on <self:AArrayExpr> */
6039 var21 = var23;
6040 RET_LABEL22:(void)0;
6041 }
6042 }
6043 {
6044 nit___nit__RapidTypeVisitor___add_callsite(var_v, var21); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_callsite on <var_v:RapidTypeVisitor>*/
6045 }
6046 RET_LABEL:;
6047 }
6048 /* method rapid_type_analysis#AStringFormExpr#accept_rapid_type_visitor for (self: AStringFormExpr, RapidTypeVisitor) */
6049 void nit__rapid_type_analysis___AStringFormExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
6050 val* var_v /* var v: RapidTypeVisitor */;
6051 val* var /* : RapidTypeAnalysis */;
6052 val* var2 /* : RapidTypeAnalysis */;
6053 val* var3 /* : MModule */;
6054 val* var5 /* : MModule */;
6055 val* var6 /* : MClassType */;
6056 val* var_native /* var native: MClassType */;
6057 static val* varonce;
6058 val* var7 /* : String */;
6059 char* var8 /* : NativeString */;
6060 val* var9 /* : FlatString */;
6061 val* var10 /* : MMethod */;
6062 val* var_prop /* var prop: MMethod */;
6063 var_v = p0;
6064 {
6065 { /* Inline rapid_type_analysis#RapidTypeVisitor#analysis (var_v) on <var_v:RapidTypeVisitor> */
6066 var2 = var_v->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <var_v:RapidTypeVisitor> */
6067 if (unlikely(var2 == NULL)) {
6068 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
6069 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 447);
6070 fatal_exit(1);
6071 }
6072 var = var2;
6073 RET_LABEL1:(void)0;
6074 }
6075 }
6076 {
6077 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (var) on <var:RapidTypeAnalysis> */
6078 var5 = var->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <var:RapidTypeAnalysis> */
6079 if (unlikely(var5 == NULL)) {
6080 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
6081 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
6082 fatal_exit(1);
6083 }
6084 var3 = var5;
6085 RET_LABEL4:(void)0;
6086 }
6087 }
6088 {
6089 var6 = nit__model___MModule___native_string_type(var3);
6090 }
6091 var_native = var6;
6092 {
6093 nit___nit__RapidTypeVisitor___add_type(var_v, var_native); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_type on <var_v:RapidTypeVisitor>*/
6094 }
6095 if (likely(varonce!=NULL)) {
6096 var7 = varonce;
6097 } else {
6098 var8 = "to_s_with_length";
6099 var9 = standard___standard__NativeString___to_s_with_length(var8, 16l);
6100 var7 = var9;
6101 varonce = var7;
6102 }
6103 {
6104 var10 = nit___nit__RapidTypeVisitor___get_method(var_v, var_native, var7);
6105 }
6106 var_prop = var10;
6107 {
6108 nit___nit__RapidTypeVisitor___add_monomorphic_send(var_v, var_native, var_prop); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_monomorphic_send on <var_v:RapidTypeVisitor>*/
6109 }
6110 RET_LABEL:;
6111 }
6112 /* method rapid_type_analysis#ASuperstringExpr#accept_rapid_type_visitor for (self: ASuperstringExpr, RapidTypeVisitor) */
6113 void nit__rapid_type_analysis___ASuperstringExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
6114 val* var_v /* var v: RapidTypeVisitor */;
6115 val* var /* : RapidTypeAnalysis */;
6116 val* var2 /* : RapidTypeAnalysis */;
6117 val* var3 /* : MModule */;
6118 val* var5 /* : MModule */;
6119 val* var_mmodule /* var mmodule: MModule */;
6120 val* var6 /* : MClassType */;
6121 val* var_object_type /* var object_type: MClassType */;
6122 val* var7 /* : MClassType */;
6123 val* var_arraytype /* var arraytype: MClassType */;
6124 val* var8 /* : MClassType */;
6125 val* var_nattype /* var nattype: MClassType */;
6126 static val* varonce;
6127 val* var9 /* : String */;
6128 char* var10 /* : NativeString */;
6129 val* var11 /* : FlatString */;
6130 val* var12 /* : MMethod */;
6131 val* var_prop /* var prop: MMethod */;
6132 static val* varonce13;
6133 val* var14 /* : String */;
6134 char* var15 /* : NativeString */;
6135 val* var16 /* : FlatString */;
6136 val* var17 /* : MMethod */;
6137 val* var_prop2 /* var prop2: MMethod */;
6138 static val* varonce18;
6139 val* var19 /* : String */;
6140 char* var20 /* : NativeString */;
6141 val* var21 /* : FlatString */;
6142 val* var22 /* : MMethod */;
6143 var_v = p0;
6144 {
6145 { /* Inline rapid_type_analysis#RapidTypeVisitor#analysis (var_v) on <var_v:RapidTypeVisitor> */
6146 var2 = var_v->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <var_v:RapidTypeVisitor> */
6147 if (unlikely(var2 == NULL)) {
6148 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
6149 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 447);
6150 fatal_exit(1);
6151 }
6152 var = var2;
6153 RET_LABEL1:(void)0;
6154 }
6155 }
6156 {
6157 { /* Inline rapid_type_analysis#RapidTypeAnalysis#mainmodule (var) on <var:RapidTypeAnalysis> */
6158 var5 = var->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <var:RapidTypeAnalysis> */
6159 if (unlikely(var5 == NULL)) {
6160 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
6161 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 56);
6162 fatal_exit(1);
6163 }
6164 var3 = var5;
6165 RET_LABEL4:(void)0;
6166 }
6167 }
6168 var_mmodule = var3;
6169 {
6170 var6 = nit__model___MModule___string_type(var_mmodule);
6171 }
6172 var_object_type = var6;
6173 {
6174 var7 = nit__model___MModule___array_type(var_mmodule, var_object_type);
6175 }
6176 var_arraytype = var7;
6177 {
6178 nit___nit__RapidTypeVisitor___add_type(var_v, var_arraytype); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_type on <var_v:RapidTypeVisitor>*/
6179 }
6180 {
6181 var8 = nit__model___MModule___native_array_type(var_mmodule, var_object_type);
6182 }
6183 var_nattype = var8;
6184 {
6185 nit___nit__RapidTypeVisitor___add_type(var_v, var_nattype); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_type on <var_v:RapidTypeVisitor>*/
6186 }
6187 if (likely(varonce!=NULL)) {
6188 var9 = varonce;
6189 } else {
6190 var10 = "join";
6191 var11 = standard___standard__NativeString___to_s_with_length(var10, 4l);
6192 var9 = var11;
6193 varonce = var9;
6194 }
6195 {
6196 var12 = nit___nit__RapidTypeVisitor___get_method(var_v, var_arraytype, var9);
6197 }
6198 var_prop = var12;
6199 {
6200 nit___nit__RapidTypeVisitor___add_monomorphic_send(var_v, var_arraytype, var_prop); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_monomorphic_send on <var_v:RapidTypeVisitor>*/
6201 }
6202 if (likely(varonce13!=NULL)) {
6203 var14 = varonce13;
6204 } else {
6205 var15 = "with_native";
6206 var16 = standard___standard__NativeString___to_s_with_length(var15, 11l);
6207 var14 = var16;
6208 varonce13 = var14;
6209 }
6210 {
6211 var17 = nit___nit__RapidTypeVisitor___get_method(var_v, var_arraytype, var14);
6212 }
6213 var_prop2 = var17;
6214 {
6215 nit___nit__RapidTypeVisitor___add_monomorphic_send(var_v, var_arraytype, var_prop2); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_monomorphic_send on <var_v:RapidTypeVisitor>*/
6216 }
6217 if (likely(varonce18!=NULL)) {
6218 var19 = varonce18;
6219 } else {
6220 var20 = "native_to_s";
6221 var21 = standard___standard__NativeString___to_s_with_length(var20, 11l);
6222 var19 = var21;
6223 varonce18 = var19;
6224 }
6225 {
6226 var22 = nit___nit__RapidTypeVisitor___get_method(var_v, var_nattype, var19);
6227 }
6228 {
6229 nit___nit__RapidTypeVisitor___add_monomorphic_send(var_v, var_nattype, var22); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_monomorphic_send on <var_v:RapidTypeVisitor>*/
6230 }
6231 RET_LABEL:;
6232 }
6233 /* method rapid_type_analysis#ACrangeExpr#accept_rapid_type_visitor for (self: ACrangeExpr, RapidTypeVisitor) */
6234 void nit__rapid_type_analysis___ACrangeExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
6235 val* var_v /* var v: RapidTypeVisitor */;
6236 val* var /* : nullable MType */;
6237 val* var2 /* : nullable MType */;
6238 short int var3 /* : Bool */;
6239 int cltype;
6240 int idtype;
6241 const char* var_class_name;
6242 val* var_mtype /* var mtype: MClassType */;
6243 val* var4 /* : nullable CallSite */;
6244 val* var6 /* : nullable CallSite */;
6245 var_v = p0;
6246 {
6247 { /* Inline typing#AExpr#mtype (self) on <self:ACrangeExpr> */
6248 var2 = self->attrs[COLOR_nit__typing__AExpr___mtype].val; /* _mtype on <self:ACrangeExpr> */
6249 var = var2;
6250 RET_LABEL1:(void)0;
6251 }
6252 }
6253 /* <var:nullable MType> isa MClassType */
6254 cltype = type_nit__MClassType.color;
6255 idtype = type_nit__MClassType.id;
6256 if(var == NULL) {
6257 var3 = 0;
6258 } else {
6259 if(cltype >= var->type->table_size) {
6260 var3 = 0;
6261 } else {
6262 var3 = var->type->type_table[cltype] == idtype;
6263 }
6264 }
6265 if (unlikely(!var3)) {
6266 var_class_name = var == NULL ? "null" : var->type->name;
6267 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
6268 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 595);
6269 fatal_exit(1);
6270 }
6271 var_mtype = var;
6272 {
6273 nit___nit__RapidTypeVisitor___add_type(var_v, var_mtype); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_type on <var_v:RapidTypeVisitor>*/
6274 }
6275 {
6276 { /* Inline typing#ARangeExpr#init_callsite (self) on <self:ACrangeExpr> */
6277 var6 = self->attrs[COLOR_nit__typing__ARangeExpr___init_callsite].val; /* _init_callsite on <self:ACrangeExpr> */
6278 var4 = var6;
6279 RET_LABEL5:(void)0;
6280 }
6281 }
6282 {
6283 nit___nit__RapidTypeVisitor___add_callsite(var_v, var4); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_callsite on <var_v:RapidTypeVisitor>*/
6284 }
6285 RET_LABEL:;
6286 }
6287 /* method rapid_type_analysis#AOrangeExpr#accept_rapid_type_visitor for (self: AOrangeExpr, RapidTypeVisitor) */
6288 void nit__rapid_type_analysis___AOrangeExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
6289 val* var_v /* var v: RapidTypeVisitor */;
6290 val* var /* : nullable MType */;
6291 val* var2 /* : nullable MType */;
6292 short int var3 /* : Bool */;
6293 int cltype;
6294 int idtype;
6295 const char* var_class_name;
6296 val* var_mtype /* var mtype: MClassType */;
6297 val* var4 /* : nullable CallSite */;
6298 val* var6 /* : nullable CallSite */;
6299 var_v = p0;
6300 {
6301 { /* Inline typing#AExpr#mtype (self) on <self:AOrangeExpr> */
6302 var2 = self->attrs[COLOR_nit__typing__AExpr___mtype].val; /* _mtype on <self:AOrangeExpr> */
6303 var = var2;
6304 RET_LABEL1:(void)0;
6305 }
6306 }
6307 /* <var:nullable MType> isa MClassType */
6308 cltype = type_nit__MClassType.color;
6309 idtype = type_nit__MClassType.id;
6310 if(var == NULL) {
6311 var3 = 0;
6312 } else {
6313 if(cltype >= var->type->table_size) {
6314 var3 = 0;
6315 } else {
6316 var3 = var->type->type_table[cltype] == idtype;
6317 }
6318 }
6319 if (unlikely(!var3)) {
6320 var_class_name = var == NULL ? "null" : var->type->name;
6321 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
6322 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 604);
6323 fatal_exit(1);
6324 }
6325 var_mtype = var;
6326 {
6327 nit___nit__RapidTypeVisitor___add_type(var_v, var_mtype); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_type on <var_v:RapidTypeVisitor>*/
6328 }
6329 {
6330 { /* Inline typing#ARangeExpr#init_callsite (self) on <self:AOrangeExpr> */
6331 var6 = self->attrs[COLOR_nit__typing__ARangeExpr___init_callsite].val; /* _init_callsite on <self:AOrangeExpr> */
6332 var4 = var6;
6333 RET_LABEL5:(void)0;
6334 }
6335 }
6336 {
6337 nit___nit__RapidTypeVisitor___add_callsite(var_v, var4); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_callsite on <var_v:RapidTypeVisitor>*/
6338 }
6339 RET_LABEL:;
6340 }
6341 /* method rapid_type_analysis#ATrueExpr#accept_rapid_type_visitor for (self: ATrueExpr, RapidTypeVisitor) */
6342 void nit__rapid_type_analysis___ATrueExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
6343 val* var_v /* var v: RapidTypeVisitor */;
6344 val* var /* : nullable MType */;
6345 val* var2 /* : nullable MType */;
6346 short int var3 /* : Bool */;
6347 int cltype;
6348 int idtype;
6349 const char* var_class_name;
6350 var_v = p0;
6351 {
6352 { /* Inline typing#AExpr#mtype (self) on <self:ATrueExpr> */
6353 var2 = self->attrs[COLOR_nit__typing__AExpr___mtype].val; /* _mtype on <self:ATrueExpr> */
6354 var = var2;
6355 RET_LABEL1:(void)0;
6356 }
6357 }
6358 /* <var:nullable MType> isa MClassType */
6359 cltype = type_nit__MClassType.color;
6360 idtype = type_nit__MClassType.id;
6361 if(var == NULL) {
6362 var3 = 0;
6363 } else {
6364 if(cltype >= var->type->table_size) {
6365 var3 = 0;
6366 } else {
6367 var3 = var->type->type_table[cltype] == idtype;
6368 }
6369 }
6370 if (unlikely(!var3)) {
6371 var_class_name = var == NULL ? "null" : var->type->name;
6372 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
6373 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 613);
6374 fatal_exit(1);
6375 }
6376 {
6377 nit___nit__RapidTypeVisitor___add_type(var_v, var); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_type on <var_v:RapidTypeVisitor>*/
6378 }
6379 RET_LABEL:;
6380 }
6381 /* method rapid_type_analysis#AFalseExpr#accept_rapid_type_visitor for (self: AFalseExpr, RapidTypeVisitor) */
6382 void nit__rapid_type_analysis___AFalseExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
6383 val* var_v /* var v: RapidTypeVisitor */;
6384 val* var /* : nullable MType */;
6385 val* var2 /* : nullable MType */;
6386 short int var3 /* : Bool */;
6387 int cltype;
6388 int idtype;
6389 const char* var_class_name;
6390 var_v = p0;
6391 {
6392 { /* Inline typing#AExpr#mtype (self) on <self:AFalseExpr> */
6393 var2 = self->attrs[COLOR_nit__typing__AExpr___mtype].val; /* _mtype on <self:AFalseExpr> */
6394 var = var2;
6395 RET_LABEL1:(void)0;
6396 }
6397 }
6398 /* <var:nullable MType> isa MClassType */
6399 cltype = type_nit__MClassType.color;
6400 idtype = type_nit__MClassType.id;
6401 if(var == NULL) {
6402 var3 = 0;
6403 } else {
6404 if(cltype >= var->type->table_size) {
6405 var3 = 0;
6406 } else {
6407 var3 = var->type->type_table[cltype] == idtype;
6408 }
6409 }
6410 if (unlikely(!var3)) {
6411 var_class_name = var == NULL ? "null" : var->type->name;
6412 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
6413 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 620);
6414 fatal_exit(1);
6415 }
6416 {
6417 nit___nit__RapidTypeVisitor___add_type(var_v, var); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_type on <var_v:RapidTypeVisitor>*/
6418 }
6419 RET_LABEL:;
6420 }
6421 /* method rapid_type_analysis#AIsaExpr#accept_rapid_type_visitor for (self: AIsaExpr, RapidTypeVisitor) */
6422 void nit__rapid_type_analysis___AIsaExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
6423 val* var_v /* var v: RapidTypeVisitor */;
6424 val* var /* : nullable MType */;
6425 val* var2 /* : nullable MType */;
6426 var_v = p0;
6427 {
6428 { /* Inline typing#AIsaExpr#cast_type (self) on <self:AIsaExpr> */
6429 var2 = self->attrs[COLOR_nit__typing__AIsaExpr___cast_type].val; /* _cast_type on <self:AIsaExpr> */
6430 var = var2;
6431 RET_LABEL1:(void)0;
6432 }
6433 }
6434 if (unlikely(var == NULL)) {
6435 PRINT_ERROR("Runtime error: %s", "Cast failed");
6436 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 627);
6437 fatal_exit(1);
6438 }
6439 {
6440 nit___nit__RapidTypeVisitor___add_cast_type(var_v, var); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_cast_type on <var_v:RapidTypeVisitor>*/
6441 }
6442 RET_LABEL:;
6443 }
6444 /* method rapid_type_analysis#AAsCastExpr#accept_rapid_type_visitor for (self: AAsCastExpr, RapidTypeVisitor) */
6445 void nit__rapid_type_analysis___AAsCastExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
6446 val* var_v /* var v: RapidTypeVisitor */;
6447 val* var /* : nullable MType */;
6448 val* var2 /* : nullable MType */;
6449 var_v = p0;
6450 {
6451 { /* Inline typing#AExpr#mtype (self) on <self:AAsCastExpr> */
6452 var2 = self->attrs[COLOR_nit__typing__AExpr___mtype].val; /* _mtype on <self:AAsCastExpr> */
6453 var = var2;
6454 RET_LABEL1:(void)0;
6455 }
6456 }
6457 if (unlikely(var == NULL)) {
6458 PRINT_ERROR("Runtime error: %s", "Cast failed");
6459 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 634);
6460 fatal_exit(1);
6461 }
6462 {
6463 nit___nit__RapidTypeVisitor___add_cast_type(var_v, var); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_cast_type on <var_v:RapidTypeVisitor>*/
6464 }
6465 RET_LABEL:;
6466 }
6467 /* method rapid_type_analysis#ASendExpr#accept_rapid_type_visitor for (self: ASendExpr, RapidTypeVisitor) */
6468 void nit__rapid_type_analysis___ASendExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
6469 val* var_v /* var v: RapidTypeVisitor */;
6470 val* var /* : nullable CallSite */;
6471 val* var2 /* : nullable CallSite */;
6472 var_v = p0;
6473 {
6474 { /* Inline typing#ASendExpr#callsite (self) on <self:ASendExpr> */
6475 var2 = self->attrs[COLOR_nit__typing__ASendExpr___callsite].val; /* _callsite on <self:ASendExpr> */
6476 var = var2;
6477 RET_LABEL1:(void)0;
6478 }
6479 }
6480 {
6481 nit___nit__RapidTypeVisitor___add_callsite(var_v, var); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_callsite on <var_v:RapidTypeVisitor>*/
6482 }
6483 RET_LABEL:;
6484 }
6485 /* method rapid_type_analysis#ASendReassignFormExpr#accept_rapid_type_visitor for (self: ASendReassignFormExpr, RapidTypeVisitor) */
6486 void nit__rapid_type_analysis___ASendReassignFormExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
6487 val* var_v /* var v: RapidTypeVisitor */;
6488 val* var /* : nullable CallSite */;
6489 val* var2 /* : nullable CallSite */;
6490 val* var3 /* : nullable CallSite */;
6491 val* var5 /* : nullable CallSite */;
6492 val* var6 /* : nullable CallSite */;
6493 val* var8 /* : nullable CallSite */;
6494 var_v = p0;
6495 {
6496 { /* Inline typing#ASendExpr#callsite (self) on <self:ASendReassignFormExpr> */
6497 var2 = self->attrs[COLOR_nit__typing__ASendExpr___callsite].val; /* _callsite on <self:ASendReassignFormExpr> */
6498 var = var2;
6499 RET_LABEL1:(void)0;
6500 }
6501 }
6502 {
6503 nit___nit__RapidTypeVisitor___add_callsite(var_v, var); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_callsite on <var_v:RapidTypeVisitor>*/
6504 }
6505 {
6506 { /* Inline typing#AReassignFormExpr#reassign_callsite (self) on <self:ASendReassignFormExpr> */
6507 var5 = self->attrs[COLOR_nit__typing__AReassignFormExpr___reassign_callsite].val; /* _reassign_callsite on <self:ASendReassignFormExpr> */
6508 var3 = var5;
6509 RET_LABEL4:(void)0;
6510 }
6511 }
6512 {
6513 nit___nit__RapidTypeVisitor___add_callsite(var_v, var3); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_callsite on <var_v:RapidTypeVisitor>*/
6514 }
6515 {
6516 { /* Inline typing#ASendReassignFormExpr#write_callsite (self) on <self:ASendReassignFormExpr> */
6517 var8 = self->attrs[COLOR_nit__typing__ASendReassignFormExpr___write_callsite].val; /* _write_callsite on <self:ASendReassignFormExpr> */
6518 var6 = var8;
6519 RET_LABEL7:(void)0;
6520 }
6521 }
6522 {
6523 nit___nit__RapidTypeVisitor___add_callsite(var_v, var6); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_callsite on <var_v:RapidTypeVisitor>*/
6524 }
6525 RET_LABEL:;
6526 }
6527 /* method rapid_type_analysis#AVarReassignExpr#accept_rapid_type_visitor for (self: AVarReassignExpr, RapidTypeVisitor) */
6528 void nit__rapid_type_analysis___AVarReassignExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
6529 val* var_v /* var v: RapidTypeVisitor */;
6530 val* var /* : nullable CallSite */;
6531 val* var2 /* : nullable CallSite */;
6532 var_v = p0;
6533 {
6534 { /* Inline typing#AReassignFormExpr#reassign_callsite (self) on <self:AVarReassignExpr> */
6535 var2 = self->attrs[COLOR_nit__typing__AReassignFormExpr___reassign_callsite].val; /* _reassign_callsite on <self:AVarReassignExpr> */
6536 var = var2;
6537 RET_LABEL1:(void)0;
6538 }
6539 }
6540 {
6541 nit___nit__RapidTypeVisitor___add_callsite(var_v, var); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_callsite on <var_v:RapidTypeVisitor>*/
6542 }
6543 RET_LABEL:;
6544 }
6545 /* method rapid_type_analysis#AAttrReassignExpr#accept_rapid_type_visitor for (self: AAttrReassignExpr, RapidTypeVisitor) */
6546 void nit__rapid_type_analysis___AAttrReassignExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
6547 val* var_v /* var v: RapidTypeVisitor */;
6548 val* var /* : nullable CallSite */;
6549 val* var2 /* : nullable CallSite */;
6550 var_v = p0;
6551 {
6552 { /* Inline typing#AReassignFormExpr#reassign_callsite (self) on <self:AAttrReassignExpr> */
6553 var2 = self->attrs[COLOR_nit__typing__AReassignFormExpr___reassign_callsite].val; /* _reassign_callsite on <self:AAttrReassignExpr> */
6554 var = var2;
6555 RET_LABEL1:(void)0;
6556 }
6557 }
6558 {
6559 nit___nit__RapidTypeVisitor___add_callsite(var_v, var); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_callsite on <var_v:RapidTypeVisitor>*/
6560 }
6561 RET_LABEL:;
6562 }
6563 /* method rapid_type_analysis#ASuperExpr#accept_rapid_type_visitor for (self: ASuperExpr, RapidTypeVisitor) */
6564 void nit__rapid_type_analysis___ASuperExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
6565 val* var_v /* var v: RapidTypeVisitor */;
6566 val* var /* : nullable CallSite */;
6567 val* var2 /* : nullable CallSite */;
6568 val* var_callsite /* var callsite: nullable CallSite */;
6569 short int var3 /* : Bool */;
6570 short int var4 /* : Bool */;
6571 val* var_other /* var other: nullable Object */;
6572 short int var6 /* : Bool */;
6573 short int var7 /* : Bool */;
6574 val* var8 /* : RapidTypeAnalysis */;
6575 val* var10 /* : RapidTypeAnalysis */;
6576 val* var11 /* : MClassType */;
6577 val* var13 /* : MClassType */;
6578 val* var14 /* : nullable MMethodDef */;
6579 val* var16 /* : nullable MMethodDef */;
6580 var_v = p0;
6581 {
6582 { /* Inline typing#ASuperExpr#callsite (self) on <self:ASuperExpr> */
6583 var2 = self->attrs[COLOR_nit__typing__ASuperExpr___callsite].val; /* _callsite on <self:ASuperExpr> */
6584 var = var2;
6585 RET_LABEL1:(void)0;
6586 }
6587 }
6588 var_callsite = var;
6589 if (var_callsite == NULL) {
6590 var3 = 0; /* is null */
6591 } else {
6592 var3 = 1; /* arg is null and recv is not */
6593 }
6594 if (0) {
6595 { /* Inline kernel#Object#!= (var_callsite,((val*)NULL)) on <var_callsite:nullable CallSite> */
6596 var_other = ((val*)NULL);
6597 {
6598 var6 = ((short int(*)(val* self, val* p0))(var_callsite->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_callsite, var_other); /* == on <var_callsite:nullable CallSite(CallSite)>*/
6599 }
6600 var7 = !var6;
6601 var4 = var7;
6602 goto RET_LABEL5;
6603 RET_LABEL5:(void)0;
6604 }
6605 var3 = var4;
6606 }
6607 if (var3){
6608 {
6609 nit___nit__RapidTypeVisitor___add_callsite(var_v, var_callsite); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_callsite on <var_v:RapidTypeVisitor>*/
6610 }
6611 goto RET_LABEL;
6612 } else {
6613 }
6614 {
6615 { /* Inline rapid_type_analysis#RapidTypeVisitor#analysis (var_v) on <var_v:RapidTypeVisitor> */
6616 var10 = var_v->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <var_v:RapidTypeVisitor> */
6617 if (unlikely(var10 == NULL)) {
6618 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
6619 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 447);
6620 fatal_exit(1);
6621 }
6622 var8 = var10;
6623 RET_LABEL9:(void)0;
6624 }
6625 }
6626 {
6627 { /* Inline rapid_type_analysis#RapidTypeVisitor#receiver (var_v) on <var_v:RapidTypeVisitor> */
6628 var13 = var_v->attrs[COLOR_nit__rapid_type_analysis__RapidTypeVisitor___receiver].val; /* _receiver on <var_v:RapidTypeVisitor> */
6629 if (unlikely(var13 == NULL)) {
6630 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _receiver");
6631 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 448);
6632 fatal_exit(1);
6633 }
6634 var11 = var13;
6635 RET_LABEL12:(void)0;
6636 }
6637 }
6638 {
6639 { /* Inline typing#ASuperExpr#mpropdef (self) on <self:ASuperExpr> */
6640 var16 = self->attrs[COLOR_nit__typing__ASuperExpr___mpropdef].val; /* _mpropdef on <self:ASuperExpr> */
6641 var14 = var16;
6642 RET_LABEL15:(void)0;
6643 }
6644 }
6645 if (unlikely(var14 == NULL)) {
6646 PRINT_ERROR("Runtime error: %s", "Cast failed");
6647 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 678);
6648 fatal_exit(1);
6649 }
6650 {
6651 nit___nit__RapidTypeAnalysis___add_super_send(var8, var11, var14); /* Direct call rapid_type_analysis#RapidTypeAnalysis#add_super_send on <var8:RapidTypeAnalysis>*/
6652 }
6653 RET_LABEL:;
6654 }
6655 /* method rapid_type_analysis#AForExpr#accept_rapid_type_visitor for (self: AForExpr, RapidTypeVisitor) */
6656 void nit__rapid_type_analysis___AForExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
6657 val* var_v /* var v: RapidTypeVisitor */;
6658 val* var /* : nullable CallSite */;
6659 val* var2 /* : nullable CallSite */;
6660 val* var3 /* : nullable CallSite */;
6661 val* var5 /* : nullable CallSite */;
6662 val* var6 /* : nullable Array[Variable] */;
6663 val* var8 /* : nullable Array[Variable] */;
6664 long var9 /* : Int */;
6665 long var11 /* : Int */;
6666 short int var12 /* : Bool */;
6667 short int var14 /* : Bool */;
6668 val* var15 /* : nullable CallSite */;
6669 val* var17 /* : nullable CallSite */;
6670 val* var18 /* : nullable Array[Variable] */;
6671 val* var20 /* : nullable Array[Variable] */;
6672 long var21 /* : Int */;
6673 long var23 /* : Int */;
6674 short int var24 /* : Bool */;
6675 short int var26 /* : Bool */;
6676 val* var27 /* : nullable CallSite */;
6677 val* var29 /* : nullable CallSite */;
6678 val* var30 /* : nullable CallSite */;
6679 val* var32 /* : nullable CallSite */;
6680 val* var33 /* : nullable CallSite */;
6681 val* var35 /* : nullable CallSite */;
6682 val* var36 /* : nullable CallSite */;
6683 val* var38 /* : nullable CallSite */;
6684 val* var_mf /* var mf: nullable CallSite */;
6685 short int var39 /* : Bool */;
6686 short int var40 /* : Bool */;
6687 val* var_other /* var other: nullable Object */;
6688 short int var42 /* : Bool */;
6689 short int var43 /* : Bool */;
6690 var_v = p0;
6691 {
6692 { /* Inline typing#AForExpr#method_iterator (self) on <self:AForExpr> */
6693 var2 = self->attrs[COLOR_nit__typing__AForExpr___method_iterator].val; /* _method_iterator on <self:AForExpr> */
6694 var = var2;
6695 RET_LABEL1:(void)0;
6696 }
6697 }
6698 {
6699 nit___nit__RapidTypeVisitor___add_callsite(var_v, var); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_callsite on <var_v:RapidTypeVisitor>*/
6700 }
6701 {
6702 { /* Inline typing#AForExpr#method_is_ok (self) on <self:AForExpr> */
6703 var5 = self->attrs[COLOR_nit__typing__AForExpr___method_is_ok].val; /* _method_is_ok on <self:AForExpr> */
6704 var3 = var5;
6705 RET_LABEL4:(void)0;
6706 }
6707 }
6708 {
6709 nit___nit__RapidTypeVisitor___add_callsite(var_v, var3); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_callsite on <var_v:RapidTypeVisitor>*/
6710 }
6711 {
6712 { /* Inline scope#AForExpr#variables (self) on <self:AForExpr> */
6713 var8 = self->attrs[COLOR_nit__scope__AForExpr___variables].val; /* _variables on <self:AForExpr> */
6714 var6 = var8;
6715 RET_LABEL7:(void)0;
6716 }
6717 }
6718 if (var6 == NULL) {
6719 PRINT_ERROR("Runtime error: %s", "Receiver is null");
6720 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 687);
6721 fatal_exit(1);
6722 } else {
6723 { /* Inline array#AbstractArrayRead#length (var6) on <var6:nullable Array[Variable]> */
6724 if (unlikely(var6 == NULL)) {
6725 PRINT_ERROR("Runtime error: %s", "Receiver is null");
6726 PRINT_ERROR(" (%s:%d)\n", FILE_standard__array, 26);
6727 fatal_exit(1);
6728 }
6729 var11 = var6->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on <var6:nullable Array[Variable]> */
6730 var9 = var11;
6731 RET_LABEL10:(void)0;
6732 }
6733 }
6734 {
6735 { /* Inline kernel#Int#== (var9,1l) on <var9:Int> */
6736 var14 = var9 == 1l;
6737 var12 = var14;
6738 goto RET_LABEL13;
6739 RET_LABEL13:(void)0;
6740 }
6741 }
6742 if (var12){
6743 {
6744 { /* Inline typing#AForExpr#method_item (self) on <self:AForExpr> */
6745 var17 = self->attrs[COLOR_nit__typing__AForExpr___method_item].val; /* _method_item on <self:AForExpr> */
6746 var15 = var17;
6747 RET_LABEL16:(void)0;
6748 }
6749 }
6750 {
6751 nit___nit__RapidTypeVisitor___add_callsite(var_v, var15); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_callsite on <var_v:RapidTypeVisitor>*/
6752 }
6753 } else {
6754 {
6755 { /* Inline scope#AForExpr#variables (self) on <self:AForExpr> */
6756 var20 = self->attrs[COLOR_nit__scope__AForExpr___variables].val; /* _variables on <self:AForExpr> */
6757 var18 = var20;
6758 RET_LABEL19:(void)0;
6759 }
6760 }
6761 if (var18 == NULL) {
6762 PRINT_ERROR("Runtime error: %s", "Receiver is null");
6763 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 689);
6764 fatal_exit(1);
6765 } else {
6766 { /* Inline array#AbstractArrayRead#length (var18) on <var18:nullable Array[Variable]> */
6767 if (unlikely(var18 == NULL)) {
6768 PRINT_ERROR("Runtime error: %s", "Receiver is null");
6769 PRINT_ERROR(" (%s:%d)\n", FILE_standard__array, 26);
6770 fatal_exit(1);
6771 }
6772 var23 = var18->attrs[COLOR_standard__array__AbstractArrayRead___length].l; /* _length on <var18:nullable Array[Variable]> */
6773 var21 = var23;
6774 RET_LABEL22:(void)0;
6775 }
6776 }
6777 {
6778 { /* Inline kernel#Int#== (var21,2l) on <var21:Int> */
6779 var26 = var21 == 2l;
6780 var24 = var26;
6781 goto RET_LABEL25;
6782 RET_LABEL25:(void)0;
6783 }
6784 }
6785 if (var24){
6786 {
6787 { /* Inline typing#AForExpr#method_key (self) on <self:AForExpr> */
6788 var29 = self->attrs[COLOR_nit__typing__AForExpr___method_key].val; /* _method_key on <self:AForExpr> */
6789 var27 = var29;
6790 RET_LABEL28:(void)0;
6791 }
6792 }
6793 {
6794 nit___nit__RapidTypeVisitor___add_callsite(var_v, var27); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_callsite on <var_v:RapidTypeVisitor>*/
6795 }
6796 {
6797 { /* Inline typing#AForExpr#method_item (self) on <self:AForExpr> */
6798 var32 = self->attrs[COLOR_nit__typing__AForExpr___method_item].val; /* _method_item on <self:AForExpr> */
6799 var30 = var32;
6800 RET_LABEL31:(void)0;
6801 }
6802 }
6803 {
6804 nit___nit__RapidTypeVisitor___add_callsite(var_v, var30); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_callsite on <var_v:RapidTypeVisitor>*/
6805 }
6806 } else {
6807 PRINT_ERROR("Runtime error: %s", "Aborted");
6808 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 693);
6809 fatal_exit(1);
6810 }
6811 }
6812 {
6813 { /* Inline typing#AForExpr#method_next (self) on <self:AForExpr> */
6814 var35 = self->attrs[COLOR_nit__typing__AForExpr___method_next].val; /* _method_next on <self:AForExpr> */
6815 var33 = var35;
6816 RET_LABEL34:(void)0;
6817 }
6818 }
6819 {
6820 nit___nit__RapidTypeVisitor___add_callsite(var_v, var33); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_callsite on <var_v:RapidTypeVisitor>*/
6821 }
6822 {
6823 { /* Inline typing#AForExpr#method_finish (self) on <self:AForExpr> */
6824 var38 = self->attrs[COLOR_nit__typing__AForExpr___method_finish].val; /* _method_finish on <self:AForExpr> */
6825 var36 = var38;
6826 RET_LABEL37:(void)0;
6827 }
6828 }
6829 var_mf = var36;
6830 if (var_mf == NULL) {
6831 var39 = 0; /* is null */
6832 } else {
6833 var39 = 1; /* arg is null and recv is not */
6834 }
6835 if (0) {
6836 { /* Inline kernel#Object#!= (var_mf,((val*)NULL)) on <var_mf:nullable CallSite> */
6837 var_other = ((val*)NULL);
6838 {
6839 var42 = ((short int(*)(val* self, val* p0))(var_mf->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_mf, var_other); /* == on <var_mf:nullable CallSite(CallSite)>*/
6840 }
6841 var43 = !var42;
6842 var40 = var43;
6843 goto RET_LABEL41;
6844 RET_LABEL41:(void)0;
6845 }
6846 var39 = var40;
6847 }
6848 if (var39){
6849 {
6850 nit___nit__RapidTypeVisitor___add_callsite(var_v, var_mf); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_callsite on <var_v:RapidTypeVisitor>*/
6851 }
6852 } else {
6853 }
6854 RET_LABEL:;
6855 }
6856 /* method rapid_type_analysis#ANewExpr#accept_rapid_type_visitor for (self: ANewExpr, RapidTypeVisitor) */
6857 void nit__rapid_type_analysis___ANewExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
6858 val* var_v /* var v: RapidTypeVisitor */;
6859 val* var /* : nullable MClassType */;
6860 val* var2 /* : nullable MClassType */;
6861 val* var_mtype /* var mtype: MClassType */;
6862 val* var3 /* : nullable CallSite */;
6863 val* var5 /* : nullable CallSite */;
6864 var_v = p0;
6865 {
6866 { /* Inline typing#ANewExpr#recvtype (self) on <self:ANewExpr> */
6867 var2 = self->attrs[COLOR_nit__typing__ANewExpr___recvtype].val; /* _recvtype on <self:ANewExpr> */
6868 var = var2;
6869 RET_LABEL1:(void)0;
6870 }
6871 }
6872 if (unlikely(var == NULL)) {
6873 PRINT_ERROR("Runtime error: %s", "Cast failed");
6874 PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 704);
6875 fatal_exit(1);
6876 }
6877 var_mtype = var;
6878 {
6879 nit___nit__RapidTypeVisitor___add_type(var_v, var_mtype); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_type on <var_v:RapidTypeVisitor>*/
6880 }
6881 {
6882 { /* Inline typing#ANewExpr#callsite (self) on <self:ANewExpr> */
6883 var5 = self->attrs[COLOR_nit__typing__ANewExpr___callsite].val; /* _callsite on <self:ANewExpr> */
6884 var3 = var5;
6885 RET_LABEL4:(void)0;
6886 }
6887 }
6888 {
6889 nit___nit__RapidTypeVisitor___add_callsite(var_v, var3); /* Direct call rapid_type_analysis#RapidTypeVisitor#add_callsite on <var_v:RapidTypeVisitor>*/
6890 }
6891 RET_LABEL:;
6892 }