c_src/rapid_type_analysis.sep.1.c

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