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