c_src/nitc__rapid_type_analysis.sep.1.c

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