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 ((void (*)(val*, val*, val*))(var1->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__init]))(var1, self, var_mainmodule) /* init on <var1:RapidTypeAnalysis>*/;
  11 var_analysis = var1;
  12 ((void (*)(val*))(var_analysis->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__run_analysis]))(var_analysis) /* run_analysis on <var_analysis:RapidTypeAnalysis>*/;
  13 var = var_analysis;
  14 goto RET_LABEL;
  15 RET_LABEL:;
  16 return var;
  17 }
  18 /* method rapid_type_analysis#ModelBuilder#do_rapid_type_analysis for (self: Object, MModule): RapidTypeAnalysis */
  19 val* VIRTUAL_rapid_type_analysis__ModelBuilder__do_rapid_type_analysis(val* self, val* p0) {
  20 val* var /* : RapidTypeAnalysis */;
  21 val* var1 /* : RapidTypeAnalysis */;
  22 var1 = rapid_type_analysis__ModelBuilder__do_rapid_type_analysis(self, p0);
  23 var = var1;
  24 RET_LABEL:;
  25 return var;
  26 }
  27 /* method rapid_type_analysis#RapidTypeAnalysis#modelbuilder for (self: RapidTypeAnalysis): ModelBuilder */
  28 val* rapid_type_analysis__RapidTypeAnalysis__modelbuilder(val* self) {
  29 val* var /* : ModelBuilder */;
  30 val* var1 /* : ModelBuilder */;
  31 var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dmodelbuilder].val; /* @modelbuilder on <self:RapidTypeAnalysis> */
  32 if (var1 == NULL) {
  33 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @modelbuilder");
  34 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 46);
  35 show_backtrace(1);
  36 }
  37 var = var1;
  38 RET_LABEL:;
  39 return var;
  40 }
  41 /* method rapid_type_analysis#RapidTypeAnalysis#modelbuilder for (self: Object): ModelBuilder */
  42 val* VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__modelbuilder(val* self) {
  43 val* var /* : ModelBuilder */;
  44 val* var1 /* : ModelBuilder */;
  45 var1 = rapid_type_analysis__RapidTypeAnalysis__modelbuilder(self);
  46 var = var1;
  47 RET_LABEL:;
  48 return var;
  49 }
  50 /* method rapid_type_analysis#RapidTypeAnalysis#modelbuilder= for (self: RapidTypeAnalysis, ModelBuilder) */
  51 void rapid_type_analysis__RapidTypeAnalysis__modelbuilder_61d(val* self, val* p0) {
  52 self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dmodelbuilder].val = p0; /* @modelbuilder on <self:RapidTypeAnalysis> */
  53 RET_LABEL:;
  54 }
  55 /* method rapid_type_analysis#RapidTypeAnalysis#modelbuilder= for (self: Object, ModelBuilder) */
  56 void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__modelbuilder_61d(val* self, val* p0) {
  57 rapid_type_analysis__RapidTypeAnalysis__modelbuilder_61d(self, p0);
  58 RET_LABEL:;
  59 }
  60 /* method rapid_type_analysis#RapidTypeAnalysis#mainmodule for (self: RapidTypeAnalysis): MModule */
  61 val* rapid_type_analysis__RapidTypeAnalysis__mainmodule(val* self) {
  62 val* var /* : MModule */;
  63 val* var1 /* : MModule */;
  64 var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dmainmodule].val; /* @mainmodule on <self:RapidTypeAnalysis> */
  65 if (var1 == NULL) {
  66 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @mainmodule");
  67 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 49);
  68 show_backtrace(1);
  69 }
  70 var = var1;
  71 RET_LABEL:;
  72 return var;
  73 }
  74 /* method rapid_type_analysis#RapidTypeAnalysis#mainmodule for (self: Object): MModule */
  75 val* VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__mainmodule(val* self) {
  76 val* var /* : MModule */;
  77 val* var1 /* : MModule */;
  78 var1 = rapid_type_analysis__RapidTypeAnalysis__mainmodule(self);
  79 var = var1;
  80 RET_LABEL:;
  81 return var;
  82 }
  83 /* method rapid_type_analysis#RapidTypeAnalysis#mainmodule= for (self: RapidTypeAnalysis, MModule) */
  84 void rapid_type_analysis__RapidTypeAnalysis__mainmodule_61d(val* self, val* p0) {
  85 self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dmainmodule].val = p0; /* @mainmodule on <self:RapidTypeAnalysis> */
  86 RET_LABEL:;
  87 }
  88 /* method rapid_type_analysis#RapidTypeAnalysis#mainmodule= for (self: Object, MModule) */
  89 void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__mainmodule_61d(val* self, val* p0) {
  90 rapid_type_analysis__RapidTypeAnalysis__mainmodule_61d(self, p0);
  91 RET_LABEL:;
  92 }
  93 /* method rapid_type_analysis#RapidTypeAnalysis#live_types for (self: RapidTypeAnalysis): HashSet[MClassType] */
  94 val* rapid_type_analysis__RapidTypeAnalysis__live_types(val* self) {
  95 val* var /* : HashSet[MClassType] */;
  96 val* var1 /* : HashSet[MClassType] */;
  97 var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_types].val; /* @live_types on <self:RapidTypeAnalysis> */
  98 if (var1 == NULL) {
  99 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @live_types");
 100 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 53);
 101 show_backtrace(1);
 102 }
 103 var = var1;
 104 RET_LABEL:;
 105 return var;
 106 }
 107 /* method rapid_type_analysis#RapidTypeAnalysis#live_types for (self: Object): HashSet[MClassType] */
 108 val* VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_types(val* self) {
 109 val* var /* : HashSet[MClassType] */;
 110 val* var1 /* : HashSet[MClassType] */;
 111 var1 = rapid_type_analysis__RapidTypeAnalysis__live_types(self);
 112 var = var1;
 113 RET_LABEL:;
 114 return var;
 115 }
 116 /* method rapid_type_analysis#RapidTypeAnalysis#live_types= for (self: RapidTypeAnalysis, HashSet[MClassType]) */
 117 void rapid_type_analysis__RapidTypeAnalysis__live_types_61d(val* self, val* p0) {
 118 self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_types].val = p0; /* @live_types on <self:RapidTypeAnalysis> */
 119 RET_LABEL:;
 120 }
 121 /* method rapid_type_analysis#RapidTypeAnalysis#live_types= for (self: Object, HashSet[MClassType]) */
 122 void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_types_61d(val* self, val* p0) {
 123 rapid_type_analysis__RapidTypeAnalysis__live_types_61d(self, p0);
 124 RET_LABEL:;
 125 }
 126 /* method rapid_type_analysis#RapidTypeAnalysis#live_open_types for (self: RapidTypeAnalysis): HashSet[MClassType] */
 127 val* rapid_type_analysis__RapidTypeAnalysis__live_open_types(val* self) {
 128 val* var /* : HashSet[MClassType] */;
 129 val* var1 /* : HashSet[MClassType] */;
 130 var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_open_types].val; /* @live_open_types on <self:RapidTypeAnalysis> */
 131 if (var1 == NULL) {
 132 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @live_open_types");
 133 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 58);
 134 show_backtrace(1);
 135 }
 136 var = var1;
 137 RET_LABEL:;
 138 return var;
 139 }
 140 /* method rapid_type_analysis#RapidTypeAnalysis#live_open_types for (self: Object): HashSet[MClassType] */
 141 val* VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_open_types(val* self) {
 142 val* var /* : HashSet[MClassType] */;
 143 val* var1 /* : HashSet[MClassType] */;
 144 var1 = rapid_type_analysis__RapidTypeAnalysis__live_open_types(self);
 145 var = var1;
 146 RET_LABEL:;
 147 return var;
 148 }
 149 /* method rapid_type_analysis#RapidTypeAnalysis#live_open_types= for (self: RapidTypeAnalysis, HashSet[MClassType]) */
 150 void rapid_type_analysis__RapidTypeAnalysis__live_open_types_61d(val* self, val* p0) {
 151 self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_open_types].val = p0; /* @live_open_types on <self:RapidTypeAnalysis> */
 152 RET_LABEL:;
 153 }
 154 /* method rapid_type_analysis#RapidTypeAnalysis#live_open_types= for (self: Object, HashSet[MClassType]) */
 155 void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_open_types_61d(val* self, val* p0) {
 156 rapid_type_analysis__RapidTypeAnalysis__live_open_types_61d(self, p0);
 157 RET_LABEL:;
 158 }
 159 /* method rapid_type_analysis#RapidTypeAnalysis#live_classes for (self: RapidTypeAnalysis): HashSet[MClass] */
 160 val* rapid_type_analysis__RapidTypeAnalysis__live_classes(val* self) {
 161 val* var /* : HashSet[MClass] */;
 162 val* var1 /* : HashSet[MClass] */;
 163 var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_classes].val; /* @live_classes on <self:RapidTypeAnalysis> */
 164 if (var1 == NULL) {
 165 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @live_classes");
 166 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 62);
 167 show_backtrace(1);
 168 }
 169 var = var1;
 170 RET_LABEL:;
 171 return var;
 172 }
 173 /* method rapid_type_analysis#RapidTypeAnalysis#live_classes for (self: Object): HashSet[MClass] */
 174 val* VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_classes(val* self) {
 175 val* var /* : HashSet[MClass] */;
 176 val* var1 /* : HashSet[MClass] */;
 177 var1 = rapid_type_analysis__RapidTypeAnalysis__live_classes(self);
 178 var = var1;
 179 RET_LABEL:;
 180 return var;
 181 }
 182 /* method rapid_type_analysis#RapidTypeAnalysis#live_classes= for (self: RapidTypeAnalysis, HashSet[MClass]) */
 183 void rapid_type_analysis__RapidTypeAnalysis__live_classes_61d(val* self, val* p0) {
 184 self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_classes].val = p0; /* @live_classes on <self:RapidTypeAnalysis> */
 185 RET_LABEL:;
 186 }
 187 /* method rapid_type_analysis#RapidTypeAnalysis#live_classes= for (self: Object, HashSet[MClass]) */
 188 void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_classes_61d(val* self, val* p0) {
 189 rapid_type_analysis__RapidTypeAnalysis__live_classes_61d(self, p0);
 190 RET_LABEL:;
 191 }
 192 /* method rapid_type_analysis#RapidTypeAnalysis#live_cast_types for (self: RapidTypeAnalysis): HashSet[MType] */
 193 val* rapid_type_analysis__RapidTypeAnalysis__live_cast_types(val* self) {
 194 val* var /* : HashSet[MType] */;
 195 val* var1 /* : HashSet[MType] */;
 196 var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_cast_types].val; /* @live_cast_types on <self:RapidTypeAnalysis> */
 197 if (var1 == NULL) {
 198 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @live_cast_types");
 199 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 65);
 200 show_backtrace(1);
 201 }
 202 var = var1;
 203 RET_LABEL:;
 204 return var;
 205 }
 206 /* method rapid_type_analysis#RapidTypeAnalysis#live_cast_types for (self: Object): HashSet[MType] */
 207 val* VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_cast_types(val* self) {
 208 val* var /* : HashSet[MType] */;
 209 val* var1 /* : HashSet[MType] */;
 210 var1 = rapid_type_analysis__RapidTypeAnalysis__live_cast_types(self);
 211 var = var1;
 212 RET_LABEL:;
 213 return var;
 214 }
 215 /* method rapid_type_analysis#RapidTypeAnalysis#live_cast_types= for (self: RapidTypeAnalysis, HashSet[MType]) */
 216 void rapid_type_analysis__RapidTypeAnalysis__live_cast_types_61d(val* self, val* p0) {
 217 self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_cast_types].val = p0; /* @live_cast_types on <self:RapidTypeAnalysis> */
 218 RET_LABEL:;
 219 }
 220 /* method rapid_type_analysis#RapidTypeAnalysis#live_cast_types= for (self: Object, HashSet[MType]) */
 221 void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_cast_types_61d(val* self, val* p0) {
 222 rapid_type_analysis__RapidTypeAnalysis__live_cast_types_61d(self, p0);
 223 RET_LABEL:;
 224 }
 225 /* method rapid_type_analysis#RapidTypeAnalysis#live_open_cast_types for (self: RapidTypeAnalysis): HashSet[MType] */
 226 val* rapid_type_analysis__RapidTypeAnalysis__live_open_cast_types(val* self) {
 227 val* var /* : HashSet[MType] */;
 228 val* var1 /* : HashSet[MType] */;
 229 var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_open_cast_types].val; /* @live_open_cast_types on <self:RapidTypeAnalysis> */
 230 if (var1 == NULL) {
 231 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @live_open_cast_types");
 232 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 68);
 233 show_backtrace(1);
 234 }
 235 var = var1;
 236 RET_LABEL:;
 237 return var;
 238 }
 239 /* method rapid_type_analysis#RapidTypeAnalysis#live_open_cast_types for (self: Object): HashSet[MType] */
 240 val* VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_open_cast_types(val* self) {
 241 val* var /* : HashSet[MType] */;
 242 val* var1 /* : HashSet[MType] */;
 243 var1 = rapid_type_analysis__RapidTypeAnalysis__live_open_cast_types(self);
 244 var = var1;
 245 RET_LABEL:;
 246 return var;
 247 }
 248 /* method rapid_type_analysis#RapidTypeAnalysis#live_open_cast_types= for (self: RapidTypeAnalysis, HashSet[MType]) */
 249 void rapid_type_analysis__RapidTypeAnalysis__live_open_cast_types_61d(val* self, val* p0) {
 250 self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_open_cast_types].val = p0; /* @live_open_cast_types on <self:RapidTypeAnalysis> */
 251 RET_LABEL:;
 252 }
 253 /* method rapid_type_analysis#RapidTypeAnalysis#live_open_cast_types= for (self: Object, HashSet[MType]) */
 254 void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_open_cast_types_61d(val* self, val* p0) {
 255 rapid_type_analysis__RapidTypeAnalysis__live_open_cast_types_61d(self, p0);
 256 RET_LABEL:;
 257 }
 258 /* method rapid_type_analysis#RapidTypeAnalysis#live_methoddefs for (self: RapidTypeAnalysis): HashSet[MMethodDef] */
 259 val* rapid_type_analysis__RapidTypeAnalysis__live_methoddefs(val* self) {
 260 val* var /* : HashSet[MMethodDef] */;
 261 val* var1 /* : HashSet[MMethodDef] */;
 262 var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_methoddefs].val; /* @live_methoddefs on <self:RapidTypeAnalysis> */
 263 if (var1 == NULL) {
 264 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @live_methoddefs");
 265 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 72);
 266 show_backtrace(1);
 267 }
 268 var = var1;
 269 RET_LABEL:;
 270 return var;
 271 }
 272 /* method rapid_type_analysis#RapidTypeAnalysis#live_methoddefs for (self: Object): HashSet[MMethodDef] */
 273 val* VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_methoddefs(val* self) {
 274 val* var /* : HashSet[MMethodDef] */;
 275 val* var1 /* : HashSet[MMethodDef] */;
 276 var1 = rapid_type_analysis__RapidTypeAnalysis__live_methoddefs(self);
 277 var = var1;
 278 RET_LABEL:;
 279 return var;
 280 }
 281 /* method rapid_type_analysis#RapidTypeAnalysis#live_methoddefs= for (self: RapidTypeAnalysis, HashSet[MMethodDef]) */
 282 void rapid_type_analysis__RapidTypeAnalysis__live_methoddefs_61d(val* self, val* p0) {
 283 self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_methoddefs].val = p0; /* @live_methoddefs on <self:RapidTypeAnalysis> */
 284 RET_LABEL:;
 285 }
 286 /* method rapid_type_analysis#RapidTypeAnalysis#live_methoddefs= for (self: Object, HashSet[MMethodDef]) */
 287 void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_methoddefs_61d(val* self, val* p0) {
 288 rapid_type_analysis__RapidTypeAnalysis__live_methoddefs_61d(self, p0);
 289 RET_LABEL:;
 290 }
 291 /* method rapid_type_analysis#RapidTypeAnalysis#live_methods for (self: RapidTypeAnalysis): HashSet[MMethod] */
 292 val* rapid_type_analysis__RapidTypeAnalysis__live_methods(val* self) {
 293 val* var /* : HashSet[MMethod] */;
 294 val* var1 /* : HashSet[MMethod] */;
 295 var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_methods].val; /* @live_methods on <self:RapidTypeAnalysis> */
 296 if (var1 == NULL) {
 297 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @live_methods");
 298 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 75);
 299 show_backtrace(1);
 300 }
 301 var = var1;
 302 RET_LABEL:;
 303 return var;
 304 }
 305 /* method rapid_type_analysis#RapidTypeAnalysis#live_methods for (self: Object): HashSet[MMethod] */
 306 val* VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_methods(val* self) {
 307 val* var /* : HashSet[MMethod] */;
 308 val* var1 /* : HashSet[MMethod] */;
 309 var1 = rapid_type_analysis__RapidTypeAnalysis__live_methods(self);
 310 var = var1;
 311 RET_LABEL:;
 312 return var;
 313 }
 314 /* method rapid_type_analysis#RapidTypeAnalysis#live_methods= for (self: RapidTypeAnalysis, HashSet[MMethod]) */
 315 void rapid_type_analysis__RapidTypeAnalysis__live_methods_61d(val* self, val* p0) {
 316 self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_methods].val = p0; /* @live_methods on <self:RapidTypeAnalysis> */
 317 RET_LABEL:;
 318 }
 319 /* method rapid_type_analysis#RapidTypeAnalysis#live_methods= for (self: Object, HashSet[MMethod]) */
 320 void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_methods_61d(val* self, val* p0) {
 321 rapid_type_analysis__RapidTypeAnalysis__live_methods_61d(self, p0);
 322 RET_LABEL:;
 323 }
 324 /* method rapid_type_analysis#RapidTypeAnalysis#live_super_sends for (self: RapidTypeAnalysis): HashSet[MMethodDef] */
 325 val* rapid_type_analysis__RapidTypeAnalysis__live_super_sends(val* self) {
 326 val* var /* : HashSet[MMethodDef] */;
 327 val* var1 /* : HashSet[MMethodDef] */;
 328 var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_super_sends].val; /* @live_super_sends on <self:RapidTypeAnalysis> */
 329 if (var1 == NULL) {
 330 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @live_super_sends");
 331 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 78);
 332 show_backtrace(1);
 333 }
 334 var = var1;
 335 RET_LABEL:;
 336 return var;
 337 }
 338 /* method rapid_type_analysis#RapidTypeAnalysis#live_super_sends for (self: Object): HashSet[MMethodDef] */
 339 val* VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_super_sends(val* self) {
 340 val* var /* : HashSet[MMethodDef] */;
 341 val* var1 /* : HashSet[MMethodDef] */;
 342 var1 = rapid_type_analysis__RapidTypeAnalysis__live_super_sends(self);
 343 var = var1;
 344 RET_LABEL:;
 345 return var;
 346 }
 347 /* method rapid_type_analysis#RapidTypeAnalysis#live_super_sends= for (self: RapidTypeAnalysis, HashSet[MMethodDef]) */
 348 void rapid_type_analysis__RapidTypeAnalysis__live_super_sends_61d(val* self, val* p0) {
 349 self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dlive_super_sends].val = p0; /* @live_super_sends on <self:RapidTypeAnalysis> */
 350 RET_LABEL:;
 351 }
 352 /* method rapid_type_analysis#RapidTypeAnalysis#live_super_sends= for (self: Object, HashSet[MMethodDef]) */
 353 void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_super_sends_61d(val* self, val* p0) {
 354 rapid_type_analysis__RapidTypeAnalysis__live_super_sends_61d(self, p0);
 355 RET_LABEL:;
 356 }
 357 /* method rapid_type_analysis#RapidTypeAnalysis#live_types_to_csv for (self: RapidTypeAnalysis): CSVDocument */
 358 val* rapid_type_analysis__RapidTypeAnalysis__live_types_to_csv(val* self) {
 359 val* var /* : CSVDocument */;
 360 val* var1 /* : HashSet[MType] */;
 361 val* var_typeset /* var typeset: HashSet[MType] */;
 362 val* var2 /* : HashSet[MClassType] */;
 363 val* var3 /* : HashSet[MClassType] */;
 364 val* var4 /* : HashSet[MType] */;
 365 val* var5 /* : HashSet[MType] */;
 366 val* var6 /* : Array[nullable Object] */;
 367 val* var_types /* var types: Array[MType] */;
 368 val* var7 /* : CachedAlphaComparator */;
 369 val* var8 /* : CSVDocument */;
 370 val* var_res /* var res: CSVDocument */;
 371 static val* varonce;
 372 val* var9 /* : String */;
 373 char* var10 /* : NativeString */;
 374 long var11 /* : Int */;
 375 val* var12 /* : String */;
 376 static val* varonce13;
 377 val* var14 /* : String */;
 378 char* var15 /* : NativeString */;
 379 long var16 /* : Int */;
 380 val* var17 /* : String */;
 381 static val* varonce18;
 382 val* var19 /* : String */;
 383 char* var20 /* : NativeString */;
 384 long var21 /* : Int */;
 385 val* var22 /* : String */;
 386 static val* varonce23;
 387 val* var24 /* : String */;
 388 char* var25 /* : NativeString */;
 389 long var26 /* : Int */;
 390 val* var27 /* : String */;
 391 val* var28 /* : Array[String] */;
 392 long var29 /* : Int */;
 393 val* var30 /* : NativeArray[String] */;
 394 val* var31 /* : Iterator[nullable Object] */;
 395 short int var32 /* : Bool */;
 396 val* var33 /* : nullable Object */;
 397 val* var_t /* var t: MType */;
 398 short int var34 /* : Bool */;
 399 static val* varonce35;
 400 val* var36 /* : String */;
 401 char* var37 /* : NativeString */;
 402 long var38 /* : Int */;
 403 val* var39 /* : String */;
 404 val* var_reso /* var reso: nullable Object */;
 405 static val* varonce40;
 406 val* var41 /* : String */;
 407 char* var42 /* : NativeString */;
 408 long var43 /* : Int */;
 409 val* var44 /* : String */;
 410 short int var45 /* : Bool */;
 411 short int var46 /* : Bool */;
 412 int cltype;
 413 int idtype;
 414 short int var47 /* : Bool */;
 415 val* var48 /* : HashSet[MClassType] */;
 416 short int var49 /* : Bool */;
 417 val* var50 /* : HashSet[MClassType] */;
 418 short int var51 /* : Bool */;
 419 static val* varonce52;
 420 val* var53 /* : String */;
 421 char* var54 /* : NativeString */;
 422 long var55 /* : Int */;
 423 val* var56 /* : String */;
 424 val* var_live /* var live: nullable Object */;
 425 static val* varonce57;
 426 val* var58 /* : String */;
 427 char* var59 /* : NativeString */;
 428 long var60 /* : Int */;
 429 val* var61 /* : String */;
 430 short int var62 /* : Bool */;
 431 val* var63 /* : HashSet[MType] */;
 432 short int var64 /* : Bool */;
 433 val* var65 /* : HashSet[MType] */;
 434 short int var66 /* : Bool */;
 435 static val* varonce67;
 436 val* var68 /* : String */;
 437 char* var69 /* : NativeString */;
 438 long var70 /* : Int */;
 439 val* var71 /* : String */;
 440 val* var_cast /* var cast: nullable Object */;
 441 static val* varonce72;
 442 val* var73 /* : String */;
 443 char* var74 /* : NativeString */;
 444 long var75 /* : Int */;
 445 val* var76 /* : String */;
 446 val* var77 /* : Array[Object] */;
 447 long var78 /* : Int */;
 448 val* var79 /* : NativeArray[Object] */;
 449 var1 = NEW_hash_collection__HashSet(&type_hash_collection__HashSetmodel__MType);
 450 ((void (*)(val*))(var1->class->vft[COLOR_hash_collection__HashSet__init]))(var1) /* init on <var1:HashSet[MType]>*/;
 451 var_typeset = var1;
 452 var2 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_types]))(self) /* live_types on <self:RapidTypeAnalysis>*/;
 453 ((void (*)(val*, val*))(var_typeset->class->vft[COLOR_abstract_collection__SimpleCollection__add_all]))(var_typeset, var2) /* add_all on <var_typeset:HashSet[MType]>*/;
 454 var3 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_open_types]))(self) /* live_open_types on <self:RapidTypeAnalysis>*/;
 455 ((void (*)(val*, val*))(var_typeset->class->vft[COLOR_abstract_collection__SimpleCollection__add_all]))(var_typeset, var3) /* add_all on <var_typeset:HashSet[MType]>*/;
 456 var4 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_cast_types]))(self) /* live_cast_types on <self:RapidTypeAnalysis>*/;
 457 ((void (*)(val*, val*))(var_typeset->class->vft[COLOR_abstract_collection__SimpleCollection__add_all]))(var_typeset, var4) /* add_all on <var_typeset:HashSet[MType]>*/;
 458 var5 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_open_cast_types]))(self) /* live_open_cast_types on <self:RapidTypeAnalysis>*/;
 459 ((void (*)(val*, val*))(var_typeset->class->vft[COLOR_abstract_collection__SimpleCollection__add_all]))(var_typeset, var5) /* add_all on <var_typeset:HashSet[MType]>*/;
 460 var6 = ((val* (*)(val*))(var_typeset->class->vft[COLOR_array__Collection__to_a]))(var_typeset) /* to_a on <var_typeset:HashSet[MType]>*/;
 461 var_types = var6;
 462 var7 = NEW_string__CachedAlphaComparator(&type_string__CachedAlphaComparator);
 463 ((void (*)(val*))(var7->class->vft[COLOR_string__CachedAlphaComparator__init]))(var7) /* init on <var7:CachedAlphaComparator>*/;
 464 ((void (*)(val*, val*))(var7->class->vft[COLOR_sorter__AbstractSorter__sort]))(var7, var_types) /* sort on <var7:CachedAlphaComparator>*/;
 465 var8 = NEW_csv__CSVDocument(&type_csv__CSVDocument);
 466 ((void (*)(val*))(var8->class->vft[COLOR_csv__CSVDocument__init]))(var8) /* init on <var8:CSVDocument>*/;
 467 var_res = var8;
 468 if (varonce) {
 469 var9 = varonce;
 470 } else {
 471 var10 = "Type";
 472 var11 = 4;
 473 var12 = string__NativeString__to_s_with_length(var10, var11);
 474 var9 = var12;
 475 varonce = var9;
 476 }
 477 if (varonce13) {
 478 var14 = varonce13;
 479 } else {
 480 var15 = "Resolution";
 481 var16 = 10;
 482 var17 = string__NativeString__to_s_with_length(var15, var16);
 483 var14 = var17;
 484 varonce13 = var14;
 485 }
 486 if (varonce18) {
 487 var19 = varonce18;
 488 } else {
 489 var20 = "Liveness";
 490 var21 = 8;
 491 var22 = string__NativeString__to_s_with_length(var20, var21);
 492 var19 = var22;
 493 varonce18 = var19;
 494 }
 495 if (varonce23) {
 496 var24 = varonce23;
 497 } else {
 498 var25 = "Cast-liveness";
 499 var26 = 13;
 500 var27 = string__NativeString__to_s_with_length(var25, var26);
 501 var24 = var27;
 502 varonce23 = var24;
 503 }
 504 var28 = NEW_array__Array(&type_array__Arraystring__String);
 505 { /* var28 = array_instance Array[String] */
 506 var29 = 4;
 507 var30 = NEW_array__NativeArray(var29, &type_array__NativeArraystring__String);
 508 ((struct instance_array__NativeArray*)var30)->values[0] = (val*) var9;
 509 ((struct instance_array__NativeArray*)var30)->values[1] = (val*) var14;
 510 ((struct instance_array__NativeArray*)var30)->values[2] = (val*) var19;
 511 ((struct instance_array__NativeArray*)var30)->values[3] = (val*) var24;
 512 ((void (*)(val*, val*, long))(var28->class->vft[COLOR_array__Array__with_native]))(var28, var30, var29) /* with_native on <var28:Array[String]>*/;
 513 }
 514 ((void (*)(val*, val*))(var_res->class->vft[COLOR_csv__CSVDocument__header_61d]))(var_res, var28) /* header= on <var_res:CSVDocument>*/;
 515 var31 = ((val* (*)(val*))(var_types->class->vft[COLOR_abstract_collection__Collection__iterator]))(var_types) /* iterator on <var_types:Array[MType]>*/;
 516 for(;;) {
 517 var32 = ((short int (*)(val*))(var31->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var31) /* is_ok on <var31:Iterator[nullable Object]>*/;
 518 if(!var32) break;
 519 var33 = ((val* (*)(val*))(var31->class->vft[COLOR_abstract_collection__Iterator__item]))(var31) /* item on <var31:Iterator[nullable Object]>*/;
 520 var_t = var33;
 521 var34 = ((short int (*)(val*))(var_t->class->vft[COLOR_model__MType__need_anchor]))(var_t) /* need_anchor on <var_t:MType>*/;
 522 if (var34){
 523 if (varonce35) {
 524 var36 = varonce35;
 525 } else {
 526 var37 = "OPEN ";
 527 var38 = 5;
 528 var39 = string__NativeString__to_s_with_length(var37, var38);
 529 var36 = var39;
 530 varonce35 = var36;
 531 }
 532 var_reso = var36;
 533 } else {
 534 if (varonce40) {
 535 var41 = varonce40;
 536 } else {
 537 var42 = "CLOSED";
 538 var43 = 6;
 539 var44 = string__NativeString__to_s_with_length(var42, var43);
 540 var41 = var44;
 541 varonce40 = var41;
 542 }
 543 var_reso = var41;
 544 }
 545 /* <var_t:MType> isa MClassType */
 546 cltype = type_model__MClassType.color;
 547 idtype = type_model__MClassType.id;
 548 if(cltype >= var_t->type->table_size) {
 549 var46 = 0;
 550 } else {
 551 var46 = var_t->type->type_table[cltype] == idtype;
 552 }
 553 if (!var46) {
 554 var45 = 0;
 555 } else {
 556 var48 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_types]))(self) /* live_types on <self:RapidTypeAnalysis>*/;
 557 var49 = ((short int (*)(val*, val*))(var48->class->vft[COLOR_abstract_collection__Collection__has]))(var48, var_t) /* has on <var48:HashSet[MClassType]>*/;
 558 if (var49) {
 559 var47 = 1;
 560 } else {
 561 var50 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_open_types]))(self) /* live_open_types on <self:RapidTypeAnalysis>*/;
 562 var51 = ((short int (*)(val*, val*))(var50->class->vft[COLOR_abstract_collection__Collection__has]))(var50, var_t) /* has on <var50:HashSet[MClassType]>*/;
 563 var47 = var51;
 564 }
 565 var45 = var47;
 566 }
 567 if (var45){
 568 if (varonce52) {
 569 var53 = varonce52;
 570 } else {
 571 var54 = "LIVE";
 572 var55 = 4;
 573 var56 = string__NativeString__to_s_with_length(var54, var55);
 574 var53 = var56;
 575 varonce52 = var53;
 576 }
 577 var_live = var53;
 578 } else {
 579 if (varonce57) {
 580 var58 = varonce57;
 581 } else {
 582 var59 = "DEAD";
 583 var60 = 4;
 584 var61 = string__NativeString__to_s_with_length(var59, var60);
 585 var58 = var61;
 586 varonce57 = var58;
 587 }
 588 var_live = var58;
 589 }
 590 var63 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_cast_types]))(self) /* live_cast_types on <self:RapidTypeAnalysis>*/;
 591 var64 = ((short int (*)(val*, val*))(var63->class->vft[COLOR_abstract_collection__Collection__has]))(var63, var_t) /* has on <var63:HashSet[MType]>*/;
 592 if (var64) {
 593 var62 = 1;
 594 } else {
 595 var65 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_open_cast_types]))(self) /* live_open_cast_types on <self:RapidTypeAnalysis>*/;
 596 var66 = ((short int (*)(val*, val*))(var65->class->vft[COLOR_abstract_collection__Collection__has]))(var65, var_t) /* has on <var65:HashSet[MType]>*/;
 597 var62 = var66;
 598 }
 599 if (var62){
 600 if (varonce67) {
 601 var68 = varonce67;
 602 } else {
 603 var69 = "CAST LIVE";
 604 var70 = 9;
 605 var71 = string__NativeString__to_s_with_length(var69, var70);
 606 var68 = var71;
 607 varonce67 = var68;
 608 }
 609 var_cast = var68;
 610 } else {
 611 if (varonce72) {
 612 var73 = varonce72;
 613 } else {
 614 var74 = "CAST DEAD";
 615 var75 = 9;
 616 var76 = string__NativeString__to_s_with_length(var74, var75);
 617 var73 = var76;
 618 varonce72 = var73;
 619 }
 620 var_cast = var73;
 621 }
 622 var77 = NEW_array__Array(&type_array__Arraykernel__Object);
 623 { /* var77 = array_instance Array[Object] */
 624 var78 = 4;
 625 var79 = NEW_array__NativeArray(var78, &type_array__NativeArraykernel__Object);
 626 ((struct instance_array__NativeArray*)var79)->values[0] = (val*) var_t;
 627 ((struct instance_array__NativeArray*)var79)->values[1] = (val*) var_reso;
 628 ((struct instance_array__NativeArray*)var79)->values[2] = (val*) var_live;
 629 ((struct instance_array__NativeArray*)var79)->values[3] = (val*) var_cast;
 630 ((void (*)(val*, val*, long))(var77->class->vft[COLOR_array__Array__with_native]))(var77, var79, var78) /* with_native on <var77:Array[Object]>*/;
 631 }
 632 ((void (*)(val*, val*))(var_res->class->vft[COLOR_csv__CSVDocument__add_line]))(var_res, var77) /* add_line on <var_res:CSVDocument>*/;
 633 CONTINUE_label: (void)0;
 634 ((void (*)(val*))(var31->class->vft[COLOR_abstract_collection__Iterator__next]))(var31) /* next on <var31:Iterator[nullable Object]>*/;
 635 }
 636 BREAK_label: (void)0;
 637 var = var_res;
 638 goto RET_LABEL;
 639 RET_LABEL:;
 640 return var;
 641 }
 642 /* method rapid_type_analysis#RapidTypeAnalysis#live_types_to_csv for (self: Object): CSVDocument */
 643 val* VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_types_to_csv(val* self) {
 644 val* var /* : CSVDocument */;
 645 val* var1 /* : CSVDocument */;
 646 var1 = rapid_type_analysis__RapidTypeAnalysis__live_types_to_csv(self);
 647 var = var1;
 648 RET_LABEL:;
 649 return var;
 650 }
 651 /* method rapid_type_analysis#RapidTypeAnalysis#live_methods_to_tree for (self: RapidTypeAnalysis): OrderedTree[Object] */
 652 val* rapid_type_analysis__RapidTypeAnalysis__live_methods_to_tree(val* self) {
 653 val* var /* : OrderedTree[Object] */;
 654 val* var1 /* : OrderedTree[Object] */;
 655 val* var_tree /* var tree: OrderedTree[Object] */;
 656 val* var2 /* : HashSet[MMethod] */;
 657 val* var3 /* : Iterator[nullable Object] */;
 658 short int var4 /* : Bool */;
 659 val* var5 /* : nullable Object */;
 660 val* var_x /* var x: MMethod */;
 661 val* var6 /* : String */;
 662 val* var_xn /* var xn: String */;
 663 val* var7 /* : null */;
 664 val* var8 /* : Array[MPropDef] */;
 665 val* var9 /* : Iterator[nullable Object] */;
 666 short int var10 /* : Bool */;
 667 val* var11 /* : nullable Object */;
 668 val* var_z /* var z: MMethodDef */;
 669 val* var12 /* : String */;
 670 val* var_zn /* var zn: String */;
 671 val* var13 /* : HashSet[MMethodDef] */;
 672 short int var14 /* : Bool */;
 673 val* var15 /* : HashSet[MMethodDef] */;
 674 short int var16 /* : Bool */;
 675 static val* varonce;
 676 val* var17 /* : String */;
 677 char* var18 /* : NativeString */;
 678 long var19 /* : Int */;
 679 val* var20 /* : String */;
 680 val* var21 /* : String */;
 681 val* var22 /* : HashSet[MMethodDef] */;
 682 short int var23 /* : Bool */;
 683 static val* varonce24;
 684 val* var25 /* : String */;
 685 char* var26 /* : NativeString */;
 686 long var27 /* : Int */;
 687 val* var28 /* : String */;
 688 val* var29 /* : String */;
 689 val* var31 /* : AbstractSorter[Object] */;
 690 var1 = NEW_ordered_tree__OrderedTree(&type_ordered_tree__OrderedTreekernel__Object);
 691 ((void (*)(val*))(var1->class->vft[COLOR_ordered_tree__OrderedTree__init]))(var1) /* init on <var1:OrderedTree[Object]>*/;
 692 var_tree = var1;
 693 var2 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_methods]))(self) /* live_methods on <self:RapidTypeAnalysis>*/;
 694 var3 = ((val* (*)(val*))(var2->class->vft[COLOR_abstract_collection__Collection__iterator]))(var2) /* iterator on <var2:HashSet[MMethod]>*/;
 695 for(;;) {
 696 var4 = ((short int (*)(val*))(var3->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var3) /* is_ok on <var3:Iterator[nullable Object]>*/;
 697 if(!var4) break;
 698 var5 = ((val* (*)(val*))(var3->class->vft[COLOR_abstract_collection__Iterator__item]))(var3) /* item on <var3:Iterator[nullable Object]>*/;
 699 var_x = var5;
 700 var6 = ((val* (*)(val*))(var_x->class->vft[COLOR_model__MProperty__full_name]))(var_x) /* full_name on <var_x:MMethod>*/;
 701 var_xn = var6;
 702 var7 = NULL;
 703 ((void (*)(val*, val*, val*))(var_tree->class->vft[COLOR_ordered_tree__OrderedTree__add]))(var_tree, var7, var_xn) /* add on <var_tree:OrderedTree[Object]>*/;
 704 var8 = ((val* (*)(val*))(var_x->class->vft[COLOR_model__MProperty__mpropdefs]))(var_x) /* mpropdefs on <var_x:MMethod>*/;
 705 var9 = ((val* (*)(val*))(var8->class->vft[COLOR_abstract_collection__Collection__iterator]))(var8) /* iterator on <var8:Array[MPropDef](Array[MMethodDef])>*/;
 706 for(;;) {
 707 var10 = ((short int (*)(val*))(var9->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var9) /* is_ok on <var9:Iterator[nullable Object]>*/;
 708 if(!var10) break;
 709 var11 = ((val* (*)(val*))(var9->class->vft[COLOR_abstract_collection__Iterator__item]))(var9) /* item on <var9:Iterator[nullable Object]>*/;
 710 var_z = var11;
 711 var12 = ((val* (*)(val*))(var_z->class->vft[COLOR_string__Object__to_s]))(var_z) /* to_s on <var_z:MMethodDef>*/;
 712 var_zn = var12;
 713 var13 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_methoddefs]))(self) /* live_methoddefs on <self:RapidTypeAnalysis>*/;
 714 var14 = ((short int (*)(val*, val*))(var13->class->vft[COLOR_abstract_collection__Collection__has]))(var13, var_z) /* has on <var13:HashSet[MMethodDef]>*/;
 715 if (var14){
 716 ((void (*)(val*, val*, val*))(var_tree->class->vft[COLOR_ordered_tree__OrderedTree__add]))(var_tree, var_xn, var_zn) /* add on <var_tree:OrderedTree[Object]>*/;
 717 var15 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_super_sends]))(self) /* live_super_sends on <self:RapidTypeAnalysis>*/;
 718 var16 = ((short int (*)(val*, val*))(var15->class->vft[COLOR_abstract_collection__Collection__has]))(var15, var_z) /* has on <var15:HashSet[MMethodDef]>*/;
 719 if (var16){
 720 if (varonce) {
 721 var17 = varonce;
 722 } else {
 723 var18 = "(super)";
 724 var19 = 7;
 725 var20 = string__NativeString__to_s_with_length(var18, var19);
 726 var17 = var20;
 727 varonce = var17;
 728 }
 729 var21 = ((val* (*)(val*, val*))(var_zn->class->vft[COLOR_string__String___43d]))(var_zn, var17) /* + on <var_zn:String>*/;
 730 ((void (*)(val*, val*, val*))(var_tree->class->vft[COLOR_ordered_tree__OrderedTree__add]))(var_tree, var_zn, var21) /* add on <var_tree:OrderedTree[Object]>*/;
 731 } else {
 732 }
 733 } else {
 734 var22 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_super_sends]))(self) /* live_super_sends on <self:RapidTypeAnalysis>*/;
 735 var23 = ((short int (*)(val*, val*))(var22->class->vft[COLOR_abstract_collection__Collection__has]))(var22, var_z) /* has on <var22:HashSet[MMethodDef]>*/;
 736 if (var23){
 737 if (varonce24) {
 738 var25 = varonce24;
 739 } else {
 740 var26 = "(super)";
 741 var27 = 7;
 742 var28 = string__NativeString__to_s_with_length(var26, var27);
 743 var25 = var28;
 744 varonce24 = var25;
 745 }
 746 var29 = ((val* (*)(val*, val*))(var_zn->class->vft[COLOR_string__String___43d]))(var_zn, var25) /* + on <var_zn:String>*/;
 747 ((void (*)(val*, val*, val*))(var_tree->class->vft[COLOR_ordered_tree__OrderedTree__add]))(var_tree, var_xn, var29) /* add on <var_tree:OrderedTree[Object]>*/;
 748 } else {
 749 }
 750 }
 751 CONTINUE_label: (void)0;
 752 ((void (*)(val*))(var9->class->vft[COLOR_abstract_collection__Iterator__next]))(var9) /* next on <var9:Iterator[nullable Object]>*/;
 753 }
 754 BREAK_label: (void)0;
 755 CONTINUE_label30: (void)0;
 756 ((void (*)(val*))(var3->class->vft[COLOR_abstract_collection__Iterator__next]))(var3) /* next on <var3:Iterator[nullable Object]>*/;
 757 }
 758 BREAK_label30: (void)0;
 759 var31 = ((val* (*)(val*))(self->class->vft[COLOR_string__Object__alpha_comparator]))(self) /* alpha_comparator on <self:RapidTypeAnalysis>*/;
 760 ((void (*)(val*, val*))(var_tree->class->vft[COLOR_ordered_tree__OrderedTree__sort_with]))(var_tree, var31) /* sort_with on <var_tree:OrderedTree[Object]>*/;
 761 var = var_tree;
 762 goto RET_LABEL;
 763 RET_LABEL:;
 764 return var;
 765 }
 766 /* method rapid_type_analysis#RapidTypeAnalysis#live_methods_to_tree for (self: Object): OrderedTree[Object] */
 767 val* VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__live_methods_to_tree(val* self) {
 768 val* var /* : OrderedTree[Object] */;
 769 val* var1 /* : OrderedTree[Object] */;
 770 var1 = rapid_type_analysis__RapidTypeAnalysis__live_methods_to_tree(self);
 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___64dtotry_methods].val; /* @totry_methods on <self:RapidTypeAnalysis> */
 780 if (var1 == NULL) {
 781 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @totry_methods");
 782 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 132);
 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 var1 = rapid_type_analysis__RapidTypeAnalysis__totry_methods(self);
 794 var = var1;
 795 RET_LABEL:;
 796 return var;
 797 }
 798 /* method rapid_type_analysis#RapidTypeAnalysis#totry_methods= for (self: RapidTypeAnalysis, HashSet[MMethod]) */
 799 void rapid_type_analysis__RapidTypeAnalysis__totry_methods_61d(val* self, val* p0) {
 800 self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dtotry_methods].val = p0; /* @totry_methods on <self:RapidTypeAnalysis> */
 801 RET_LABEL:;
 802 }
 803 /* method rapid_type_analysis#RapidTypeAnalysis#totry_methods= for (self: Object, HashSet[MMethod]) */
 804 void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__totry_methods_61d(val* self, val* p0) {
 805 rapid_type_analysis__RapidTypeAnalysis__totry_methods_61d(self, p0);
 806 RET_LABEL:;
 807 }
 808 /* method rapid_type_analysis#RapidTypeAnalysis#todo for (self: RapidTypeAnalysis): List[MMethodDef] */
 809 val* rapid_type_analysis__RapidTypeAnalysis__todo(val* self) {
 810 val* var /* : List[MMethodDef] */;
 811 val* var1 /* : List[MMethodDef] */;
 812 var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dtodo].val; /* @todo on <self:RapidTypeAnalysis> */
 813 if (var1 == NULL) {
 814 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @todo");
 815 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 135);
 816 show_backtrace(1);
 817 }
 818 var = var1;
 819 RET_LABEL:;
 820 return var;
 821 }
 822 /* method rapid_type_analysis#RapidTypeAnalysis#todo for (self: Object): List[MMethodDef] */
 823 val* VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__todo(val* self) {
 824 val* var /* : List[MMethodDef] */;
 825 val* var1 /* : List[MMethodDef] */;
 826 var1 = rapid_type_analysis__RapidTypeAnalysis__todo(self);
 827 var = var1;
 828 RET_LABEL:;
 829 return var;
 830 }
 831 /* method rapid_type_analysis#RapidTypeAnalysis#todo= for (self: RapidTypeAnalysis, List[MMethodDef]) */
 832 void rapid_type_analysis__RapidTypeAnalysis__todo_61d(val* self, val* p0) {
 833 self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dtodo].val = p0; /* @todo on <self:RapidTypeAnalysis> */
 834 RET_LABEL:;
 835 }
 836 /* method rapid_type_analysis#RapidTypeAnalysis#todo= for (self: Object, List[MMethodDef]) */
 837 void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__todo_61d(val* self, val* p0) {
 838 rapid_type_analysis__RapidTypeAnalysis__todo_61d(self, p0);
 839 RET_LABEL:;
 840 }
 841 /* method rapid_type_analysis#RapidTypeAnalysis#force_alive for (self: RapidTypeAnalysis, String) */
 842 void rapid_type_analysis__RapidTypeAnalysis__force_alive(val* self, val* p0) {
 843 val* var_classname /* var classname: String */;
 844 val* var /* : ModelBuilder */;
 845 val* var1 /* : Model */;
 846 val* var2 /* : nullable Array[MClass] */;
 847 val* var_classes /* var classes: nullable Array[MClass] */;
 848 val* var3 /* : null */;
 849 short int var4 /* : Bool */;
 850 val* var5 /* : Iterator[nullable Object] */;
 851 short int var6 /* : Bool */;
 852 val* var7 /* : nullable Object */;
 853 val* var_c /* var c: MClass */;
 854 val* var8 /* : MClassType */;
 855 val* var9 /* : MClassType */;
 856 var_classname = p0;
 857 var = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__modelbuilder]))(self) /* modelbuilder on <self:RapidTypeAnalysis>*/;
 858 var1 = ((val* (*)(val*))(var->class->vft[COLOR_modelbuilder__ModelBuilder__model]))(var) /* model on <var:ModelBuilder>*/;
 859 var2 = ((val* (*)(val*, val*))(var1->class->vft[COLOR_model__Model__get_mclasses_by_name]))(var1, var_classname) /* get_mclasses_by_name on <var1:Model>*/;
 860 var_classes = var2;
 861 var3 = NULL;
 862 if (var_classes == NULL) {
 863 var4 = 0; /* is null */
 864 } else {
 865 var4 = 1; /* arg is null and recv is not */
 866 }
 867 if (var4){
 868 var5 = ((val* (*)(val*))(var_classes->class->vft[COLOR_abstract_collection__Collection__iterator]))(var_classes) /* iterator on <var_classes:nullable Array[MClass](Array[MClass])>*/;
 869 for(;;) {
 870 var6 = ((short int (*)(val*))(var5->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var5) /* is_ok on <var5:Iterator[nullable Object]>*/;
 871 if(!var6) break;
 872 var7 = ((val* (*)(val*))(var5->class->vft[COLOR_abstract_collection__Iterator__item]))(var5) /* item on <var5:Iterator[nullable Object]>*/;
 873 var_c = var7;
 874 var8 = ((val* (*)(val*))(var_c->class->vft[COLOR_model__MClass__mclass_type]))(var_c) /* mclass_type on <var_c:MClass>*/;
 875 var9 = ((val* (*)(val*))(var_c->class->vft[COLOR_model__MClass__mclass_type]))(var_c) /* mclass_type on <var_c:MClass>*/;
 876 ((void (*)(val*, val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__add_new]))(self, var8, var9) /* add_new on <self:RapidTypeAnalysis>*/;
 877 CONTINUE_label: (void)0;
 878 ((void (*)(val*))(var5->class->vft[COLOR_abstract_collection__Iterator__next]))(var5) /* next on <var5:Iterator[nullable Object]>*/;
 879 }
 880 BREAK_label: (void)0;
 881 } else {
 882 }
 883 RET_LABEL:;
 884 }
 885 /* method rapid_type_analysis#RapidTypeAnalysis#force_alive for (self: Object, String) */
 886 void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__force_alive(val* self, val* p0) {
 887 rapid_type_analysis__RapidTypeAnalysis__force_alive(self, p0);
 888 RET_LABEL:;
 889 }
 890 /* method rapid_type_analysis#RapidTypeAnalysis#run_analysis for (self: RapidTypeAnalysis) */
 891 void rapid_type_analysis__RapidTypeAnalysis__run_analysis(val* self) {
 892 val* var /* : MModule */;
 893 val* var1 /* : nullable MClassType */;
 894 val* var_maintype /* var maintype: nullable MClassType */;
 895 val* var2 /* : null */;
 896 short int var3 /* : Bool */;
 897 val* var4 /* : MModule */;
 898 static val* varonce;
 899 val* var5 /* : String */;
 900 char* var6 /* : NativeString */;
 901 long var7 /* : Int */;
 902 val* var8 /* : String */;
 903 val* var9 /* : MClass */;
 904 val* var10 /* : nullable MMethod */;
 905 val* var_initprop /* var initprop: nullable MMethod */;
 906 val* var11 /* : null */;
 907 short int var12 /* : Bool */;
 908 val* var13 /* : MModule */;
 909 static val* varonce14;
 910 val* var15 /* : String */;
 911 char* var16 /* : NativeString */;
 912 long var17 /* : Int */;
 913 val* var18 /* : String */;
 914 val* var19 /* : MClass */;
 915 val* var20 /* : nullable MMethod */;
 916 val* var_mainprop /* var mainprop: nullable MMethod */;
 917 val* var21 /* : null */;
 918 short int var22 /* : Bool */;
 919 static val* varonce23;
 920 val* var24 /* : String */;
 921 char* var25 /* : NativeString */;
 922 long var26 /* : Int */;
 923 val* var27 /* : String */;
 924 static val* varonce28;
 925 val* var29 /* : String */;
 926 char* var30 /* : NativeString */;
 927 long var31 /* : Int */;
 928 val* var32 /* : String */;
 929 static val* varonce33;
 930 val* var34 /* : String */;
 931 char* var35 /* : NativeString */;
 932 long var36 /* : Int */;
 933 val* var37 /* : String */;
 934 static val* varonce38;
 935 val* var39 /* : String */;
 936 char* var40 /* : NativeString */;
 937 long var41 /* : Int */;
 938 val* var42 /* : String */;
 939 val* var43 /* : List[MMethodDef] */;
 940 short int var44 /* : Bool */;
 941 short int var45 /* : Bool */;
 942 val* var46 /* : List[MMethodDef] */;
 943 val* var47 /* : nullable Object */;
 944 val* var_mmethoddef /* var mmethoddef: MMethodDef */;
 945 val* var48 /* : RapidTypeVisitor */;
 946 val* var49 /* : MClassDef */;
 947 val* var50 /* : MClassType */;
 948 val* var_v /* var v: RapidTypeVisitor */;
 949 val* var51 /* : nullable MSignature */;
 950 long var52 /* : Int */;
 951 long var_vararg_rank /* var vararg_rank: Int */;
 952 long var53 /* : Int */;
 953 long var54 /* : Int */;
 954 long var56 /* : Int */;
 955 short int var57 /* : Bool */;
 956 short int var59 /* : Bool */;
 957 int cltype;
 958 int idtype;
 959 const char* var_class_name;
 960 short int var60 /* : Bool */;
 961 val* var61 /* : ModelBuilder */;
 962 val* var62 /* : HashMap[MPropDef, APropdef] */;
 963 val* var63 /* : nullable Object */;
 964 val* var_node /* var node: APropdef */;
 965 val* var64 /* : nullable MSignature */;
 966 val* var65 /* : Array[MParameter] */;
 967 val* var66 /* : nullable Object */;
 968 val* var67 /* : MType */;
 969 val* var_elttype /* var elttype: MType */;
 970 val* var68 /* : MModule */;
 971 static val* varonce69;
 972 val* var70 /* : String */;
 973 char* var71 /* : NativeString */;
 974 long var72 /* : Int */;
 975 val* var73 /* : String */;
 976 val* var74 /* : MClass */;
 977 val* var75 /* : Array[MType] */;
 978 long var76 /* : Int */;
 979 val* var77 /* : NativeArray[MType] */;
 980 val* var78 /* : MClassType */;
 981 val* var_vararg /* var vararg: MClassType */;
 982 val* var79 /* : MModule */;
 983 static val* varonce80;
 984 val* var81 /* : String */;
 985 char* var82 /* : NativeString */;
 986 long var83 /* : Int */;
 987 val* var84 /* : String */;
 988 val* var85 /* : MClass */;
 989 val* var86 /* : Array[MType] */;
 990 long var87 /* : Int */;
 991 val* var88 /* : NativeArray[MType] */;
 992 val* var89 /* : MClassType */;
 993 val* var_native /* var native: MClassType */;
 994 val* var90 /* : ModelBuilder */;
 995 static val* varonce91;
 996 val* var92 /* : String */;
 997 char* var93 /* : NativeString */;
 998 long var94 /* : Int */;
 999 val* var95 /* : String */;
1000 val* var96 /* : MClass */;
1001 val* var97 /* : MModule */;
1002 val* var98 /* : MMethod */;
1003 val* var99 /* : Range[Int] */;
1004 long var100 /* : Int */;
1005 val* var101 /* : nullable MSignature */;
1006 long var102 /* : Int */;
1007 val* var103 /* : Discrete */;
1008 val* var104 /* : Discrete */;
1009 val* var105 /* : Iterator[nullable Object] */;
1010 short int var106 /* : Bool */;
1011 val* var107 /* : nullable Object */;
1012 long var_i /* var i: Int */;
1013 long var108 /* : Int */;
1014 val* var109 /* : MProperty */;
1015 val* var110 /* : MPropDef */;
1016 val* var111 /* : nullable MSignature */;
1017 val* var112 /* : Array[MParameter] */;
1018 val* var113 /* : nullable Object */;
1019 val* var114 /* : MType */;
1020 val* var_origtype /* var origtype: MType */;
1021 short int var115 /* : Bool */;
1022 short int var116 /* : Bool */;
1023 val* var117 /* : nullable MSignature */;
1024 val* var118 /* : Array[MParameter] */;
1025 val* var119 /* : nullable Object */;
1026 val* var120 /* : MType */;
1027 val* var_paramtype /* var paramtype: MType */;
1028 val* var121 /* : ModelBuilder */;
1029 val* var122 /* : HashMap[MPropDef, APropdef] */;
1030 short int var123 /* : Bool */;
1031 short int var124 /* : Bool */;
1032 val* var125 /* : MProperty */;
1033 val* var126 /* : String */;
1034 static val* varonce127;
1035 val* var128 /* : String */;
1036 char* var129 /* : NativeString */;
1037 long var130 /* : Int */;
1038 val* var131 /* : String */;
1039 short int var132 /* : Bool */;
1040 val* var133 /* : ModelBuilder */;
1041 val* var134 /* : HashMap[MClassDef, AClassdef] */;
1042 val* var135 /* : MClassDef */;
1043 val* var136 /* : nullable Object */;
1044 val* var_nclassdef /* var nclassdef: AClassdef */;
1045 val* var137 /* : nullable Collection[MMethod] */;
1046 val* var_super_inits /* var super_inits: nullable Collection[MMethod] */;
1047 val* var138 /* : null */;
1048 short int var139 /* : Bool */;
1049 val* var140 /* : Iterator[nullable Object] */;
1050 short int var141 /* : Bool */;
1051 val* var142 /* : nullable Object */;
1052 val* var_su /* var su: MMethod */;
1053 val* var143 /* : MClassType */;
1054 val* var146 /* : ModelBuilder */;
1055 val* var147 /* : HashMap[MPropDef, APropdef] */;
1056 val* var148 /* : nullable Object */;
1057 val* var_npropdef /* var npropdef: APropdef */;
1058 short int var149 /* : Bool */;
1059 int cltype150;
1060 int idtype151;
1061 val* var152 /* : nullable Array[CallSite] */;
1062 val* var_auto_super_inits /* var auto_super_inits: nullable Array[CallSite] */;
1063 val* var153 /* : null */;
1064 short int var154 /* : Bool */;
1065 val* var155 /* : Iterator[nullable Object] */;
1066 short int var156 /* : Bool */;
1067 val* var157 /* : nullable Object */;
1068 val* var_auto_super_init /* var auto_super_init: CallSite */;
1069 short int var159 /* : Bool */;
1070 short int var160 /* : Bool */;
1071 int cltype161;
1072 int idtype162;
1073 short int var_ /* var : Bool */;
1074 short int var163 /* : Bool */;
1075 short int var164 /* : Bool */;
1076 int cltype165;
1077 int idtype166;
1078 short int var_167 /* var : Bool */;
1079 val* var168 /* : nullable TString */;
1080 val* var169 /* : null */;
1081 short int var170 /* : Bool */;
1082 val* var171 /* : nullable MSignature */;
1083 val* var172 /* : nullable MType */;
1084 val* var_ret /* var ret: nullable MType */;
1085 short int var173 /* : Bool */;
1086 short int var174 /* : Bool */;
1087 short int var175 /* : Bool */;
1088 val* var176 /* : null */;
1089 short int var177 /* : Bool */;
1090 short int var_178 /* var : Bool */;
1091 short int var179 /* : Bool */;
1092 int cltype180;
1093 int idtype181;
1094 short int var_182 /* var : Bool */;
1095 val* var183 /* : MClass */;
1096 val* var184 /* : MClassKind */;
1097 val* var185 /* : MClassKind */;
1098 short int var186 /* : Bool */;
1099 short int var_187 /* var : Bool */;
1100 val* var188 /* : MClass */;
1101 val* var189 /* : MClassKind */;
1102 val* var190 /* : MClassKind */;
1103 short int var191 /* : Bool */;
1104 short int var192 /* : Bool */;
1105 int cltype193;
1106 int idtype194;
1107 val* var195 /* : nullable ANode */;
1108 short int var196 /* : Bool */;
1109 int cltype197;
1110 int idtype198;
1111 const char* var_class_name199;
1112 val* var_nclassdef200 /* var nclassdef: AClassdef */;
1113 short int var201 /* : Bool */;
1114 int cltype202;
1115 int idtype203;
1116 val* var204 /* : MClassType */;
1117 val* var205 /* : List[MClassType] */;
1118 val* var_todo_types /* var todo_types: List[MClassType] */;
1119 val* var206 /* : HashSet[MClassType] */;
1120 short int var207 /* : Bool */;
1121 short int var208 /* : Bool */;
1122 val* var209 /* : nullable Object */;
1123 val* var_t /* var t: MClassType */;
1124 val* var210 /* : HashSet[MClassType] */;
1125 val* var211 /* : Iterator[nullable Object] */;
1126 short int var212 /* : Bool */;
1127 val* var213 /* : nullable Object */;
1128 val* var_ot /* var ot: MClassType */;
1129 val* var214 /* : MModule */;
1130 short int var215 /* : Bool */;
1131 short int var216 /* : Bool */;
1132 val* var218 /* : MModule */;
1133 val* var219 /* : MType */;
1134 val* var_rt /* var rt: MClassType */;
1135 val* var220 /* : HashSet[MClassType] */;
1136 short int var221 /* : Bool */;
1137 val* var222 /* : HashSet[MClassType] */;
1138 val* var224 /* : HashSet[MType] */;
1139 val* var225 /* : Iterator[nullable Object] */;
1140 short int var226 /* : Bool */;
1141 val* var227 /* : nullable Object */;
1142 val* var_ot228 /* var ot: MType */;
1143 val* var229 /* : HashSet[MClassType] */;
1144 val* var230 /* : Iterator[nullable Object] */;
1145 short int var231 /* : Bool */;
1146 val* var232 /* : nullable Object */;
1147 val* var_t233 /* var t: MClassType */;
1148 val* var234 /* : MModule */;
1149 short int var235 /* : Bool */;
1150 short int var236 /* : Bool */;
1151 val* var238 /* : MModule */;
1152 val* var239 /* : MType */;
1153 val* var_rt240 /* var rt: MType */;
1154 val* var241 /* : HashSet[MType] */;
1155 var = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on <self:RapidTypeAnalysis>*/;
1156 var1 = ((val* (*)(val*))(var->class->vft[COLOR_model__MModule__sys_type]))(var) /* sys_type on <var:MModule>*/;
1157 var_maintype = var1;
1158 var2 = NULL;
1159 if (var_maintype == NULL) {
1160 var3 = 1; /* is null */
1161 } else {
1162 var3 = 0; /* arg is null but recv is not */
1163 }
1164 if (var3){
1165 goto RET_LABEL;
1166 } else {
1167 }
1168 ((void (*)(val*, val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__add_new]))(self, var_maintype, var_maintype) /* add_new on <self:RapidTypeAnalysis>*/;
1169 var4 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on <self:RapidTypeAnalysis>*/;
1170 if (varonce) {
1171 var5 = varonce;
1172 } else {
1173 var6 = "init";
1174 var7 = 4;
1175 var8 = string__NativeString__to_s_with_length(var6, var7);
1176 var5 = var8;
1177 varonce = var5;
1178 }
1179 var9 = ((val* (*)(val*))(var_maintype->class->vft[COLOR_model__MClassType__mclass]))(var_maintype) /* mclass on <var_maintype:nullable MClassType(MClassType)>*/;
1180 var10 = ((val* (*)(val*, val*, val*))(var4->class->vft[COLOR_model__MModule__try_get_primitive_method]))(var4, var5, var9) /* try_get_primitive_method on <var4:MModule>*/;
1181 var_initprop = var10;
1182 var11 = NULL;
1183 if (var_initprop == NULL) {
1184 var12 = 0; /* is null */
1185 } else {
1186 var12 = 1; /* arg is null and recv is not */
1187 }
1188 if (var12){
1189 ((void (*)(val*, val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__add_send]))(self, var_maintype, var_initprop) /* add_send on <self:RapidTypeAnalysis>*/;
1190 } else {
1191 }
1192 var13 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on <self:RapidTypeAnalysis>*/;
1193 if (varonce14) {
1194 var15 = varonce14;
1195 } else {
1196 var16 = "main";
1197 var17 = 4;
1198 var18 = string__NativeString__to_s_with_length(var16, var17);
1199 var15 = var18;
1200 varonce14 = var15;
1201 }
1202 var19 = ((val* (*)(val*))(var_maintype->class->vft[COLOR_model__MClassType__mclass]))(var_maintype) /* mclass on <var_maintype:nullable MClassType(MClassType)>*/;
1203 var20 = ((val* (*)(val*, val*, val*))(var13->class->vft[COLOR_model__MModule__try_get_primitive_method]))(var13, var15, var19) /* try_get_primitive_method on <var13:MModule>*/;
1204 var_mainprop = var20;
1205 var21 = NULL;
1206 if (var_mainprop == NULL) {
1207 var22 = 0; /* is null */
1208 } else {
1209 var22 = 1; /* arg is null and recv is not */
1210 }
1211 if (var22){
1212 ((void (*)(val*, val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__add_send]))(self, var_maintype, var_mainprop) /* add_send on <self:RapidTypeAnalysis>*/;
1213 } else {
1214 }
1215 if (varonce23) {
1216 var24 = varonce23;
1217 } else {
1218 var25 = "Bool";
1219 var26 = 4;
1220 var27 = string__NativeString__to_s_with_length(var25, var26);
1221 var24 = var27;
1222 varonce23 = var24;
1223 }
1224 ((void (*)(val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__force_alive]))(self, var24) /* force_alive on <self:RapidTypeAnalysis>*/;
1225 if (varonce28) {
1226 var29 = varonce28;
1227 } else {
1228 var30 = "Int";
1229 var31 = 3;
1230 var32 = string__NativeString__to_s_with_length(var30, var31);
1231 var29 = var32;
1232 varonce28 = var29;
1233 }
1234 ((void (*)(val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__force_alive]))(self, var29) /* force_alive on <self:RapidTypeAnalysis>*/;
1235 if (varonce33) {
1236 var34 = varonce33;
1237 } else {
1238 var35 = "Float";
1239 var36 = 5;
1240 var37 = string__NativeString__to_s_with_length(var35, var36);
1241 var34 = var37;
1242 varonce33 = var34;
1243 }
1244 ((void (*)(val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__force_alive]))(self, var34) /* force_alive on <self:RapidTypeAnalysis>*/;
1245 if (varonce38) {
1246 var39 = varonce38;
1247 } else {
1248 var40 = "Char";
1249 var41 = 4;
1250 var42 = string__NativeString__to_s_with_length(var40, var41);
1251 var39 = var42;
1252 varonce38 = var39;
1253 }
1254 ((void (*)(val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__force_alive]))(self, var39) /* force_alive on <self:RapidTypeAnalysis>*/;
1255 for(;;) {
1256 var43 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__todo]))(self) /* todo on <self:RapidTypeAnalysis>*/;
1257 var44 = ((short int (*)(val*))(var43->class->vft[COLOR_abstract_collection__Collection__is_empty]))(var43) /* is_empty on <var43:List[MMethodDef]>*/;
1258 var45 = !var44;
1259 if (!var45) break;
1260 var46 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__todo]))(self) /* todo on <self:RapidTypeAnalysis>*/;
1261 var47 = ((val* (*)(val*))(var46->class->vft[COLOR_abstract_collection__Sequence__shift]))(var46) /* shift on <var46:List[MMethodDef]>*/;
1262 var_mmethoddef = var47;
1263 var48 = NEW_rapid_type_analysis__RapidTypeVisitor(&type_rapid_type_analysis__RapidTypeVisitor);
1264 var49 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MPropDef__mclassdef]))(var_mmethoddef) /* mclassdef on <var_mmethoddef:MMethodDef>*/;
1265 var50 = ((val* (*)(val*))(var49->class->vft[COLOR_model__MClassDef__bound_mtype]))(var49) /* bound_mtype on <var49:MClassDef>*/;
1266 ((void (*)(val*, val*, val*, val*))(var48->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__init]))(var48, self, var50, var_mmethoddef) /* init on <var48:RapidTypeVisitor>*/;
1267 var_v = var48;
1268 var51 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MMethodDef__msignature]))(var_mmethoddef) /* msignature on <var_mmethoddef:MMethodDef>*/;
1269 if (var51 == NULL) {
1270 fprintf(stderr, "Runtime error: %s", "Receiver is null");
1271 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 170);
1272 show_backtrace(1);
1273 } else {
1274 var52 = ((long (*)(val*))(var51->class->vft[COLOR_model__MSignature__vararg_rank]))(var51) /* vararg_rank on <var51:nullable MSignature>*/;
1275 }
1276 var_vararg_rank = var52;
1277 var53 = 1;
1278 { /* Inline kernel#Int#unary - (var53) */
1279 var56 = -var53;
1280 var54 = var56;
1281 goto RET_LABEL55;
1282 RET_LABEL55:(void)0;
1283 }
1284 { /* Inline kernel#Int#> (var_vararg_rank,var54) */
1285 /* Covariant cast for argument 0 (i) <var54:Int> isa OTHER */
1286 /* <var54:Int> isa OTHER */
1287 var59 = 1; /* easy <var54:Int> isa OTHER*/
1288 if (!var59) {
1289 var_class_name = type_kernel__Int.name;
1290 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
1291 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 267);
1292 show_backtrace(1);
1293 }
1294 var60 = var_vararg_rank > var54;
1295 var57 = var60;
1296 goto RET_LABEL58;
1297 RET_LABEL58:(void)0;
1298 }
1299 if (var57){
1300 var61 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__modelbuilder]))(self) /* modelbuilder on <self:RapidTypeAnalysis>*/;
1301 var62 = ((val* (*)(val*))(var61->class->vft[COLOR_modelize_property__ModelBuilder__mpropdef2npropdef]))(var61) /* mpropdef2npropdef on <var61:ModelBuilder>*/;
1302 var63 = ((val* (*)(val*, val*))(var62->class->vft[COLOR_abstract_collection__MapRead___91d_93d]))(var62, var_mmethoddef) /* [] on <var62:HashMap[MPropDef, APropdef]>*/;
1303 var_node = var63;
1304 var64 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MMethodDef__msignature]))(var_mmethoddef) /* msignature on <var_mmethoddef:MMethodDef>*/;
1305 if (var64 == NULL) {
1306 fprintf(stderr, "Runtime error: %s", "Receiver is null");
1307 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 173);
1308 show_backtrace(1);
1309 } else {
1310 var65 = ((val* (*)(val*))(var64->class->vft[COLOR_model__MSignature__mparameters]))(var64) /* mparameters on <var64:nullable MSignature>*/;
1311 }
1312 var66 = ((val* (*)(val*, long))(var65->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var65, var_vararg_rank) /* [] on <var65:Array[MParameter]>*/;
1313 var67 = ((val* (*)(val*))(var66->class->vft[COLOR_model__MParameter__mtype]))(var66) /* mtype on <var66:nullable Object(MParameter)>*/;
1314 var_elttype = var67;
1315 var68 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on <self:RapidTypeAnalysis>*/;
1316 if (varonce69) {
1317 var70 = varonce69;
1318 } else {
1319 var71 = "Array";
1320 var72 = 5;
1321 var73 = string__NativeString__to_s_with_length(var71, var72);
1322 var70 = var73;
1323 varonce69 = var70;
1324 }
1325 var74 = ((val* (*)(val*, val*))(var68->class->vft[COLOR_model__MModule__get_primitive_class]))(var68, var70) /* get_primitive_class on <var68:MModule>*/;
1326 var75 = NEW_array__Array(&type_array__Arraymodel__MType);
1327 { /* var75 = array_instance Array[MType] */
1328 var76 = 1;
1329 var77 = NEW_array__NativeArray(var76, &type_array__NativeArraymodel__MType);
1330 ((struct instance_array__NativeArray*)var77)->values[0] = (val*) var_elttype;
1331 ((void (*)(val*, val*, long))(var75->class->vft[COLOR_array__Array__with_native]))(var75, var77, var76) /* with_native on <var75:Array[MType]>*/;
1332 }
1333 var78 = ((val* (*)(val*, val*))(var74->class->vft[COLOR_model__MClass__get_mtype]))(var74, var75) /* get_mtype on <var74:MClass>*/;
1334 var_vararg = var78;
1335 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var_vararg) /* add_type on <var_v:RapidTypeVisitor>*/;
1336 var79 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on <self:RapidTypeAnalysis>*/;
1337 if (varonce80) {
1338 var81 = varonce80;
1339 } else {
1340 var82 = "NativeArray";
1341 var83 = 11;
1342 var84 = string__NativeString__to_s_with_length(var82, var83);
1343 var81 = var84;
1344 varonce80 = var81;
1345 }
1346 var85 = ((val* (*)(val*, val*))(var79->class->vft[COLOR_model__MModule__get_primitive_class]))(var79, var81) /* get_primitive_class on <var79:MModule>*/;
1347 var86 = NEW_array__Array(&type_array__Arraymodel__MType);
1348 { /* var86 = array_instance Array[MType] */
1349 var87 = 1;
1350 var88 = NEW_array__NativeArray(var87, &type_array__NativeArraymodel__MType);
1351 ((struct instance_array__NativeArray*)var88)->values[0] = (val*) var_elttype;
1352 ((void (*)(val*, val*, long))(var86->class->vft[COLOR_array__Array__with_native]))(var86, var88, var87) /* with_native on <var86:Array[MType]>*/;
1353 }
1354 var89 = ((val* (*)(val*, val*))(var85->class->vft[COLOR_model__MClass__get_mtype]))(var85, var86) /* get_mtype on <var85:MClass>*/;
1355 var_native = var89;
1356 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var_native) /* add_type on <var_v:RapidTypeVisitor>*/;
1357 var90 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__modelbuilder]))(self) /* modelbuilder on <self:RapidTypeAnalysis>*/;
1358 if (varonce91) {
1359 var92 = varonce91;
1360 } else {
1361 var93 = "with_native";
1362 var94 = 11;
1363 var95 = string__NativeString__to_s_with_length(var93, var94);
1364 var92 = var95;
1365 varonce91 = var92;
1366 }
1367 var96 = ((val* (*)(val*))(var_vararg->class->vft[COLOR_model__MClassType__mclass]))(var_vararg) /* mclass on <var_vararg:MClassType>*/;
1368 var97 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on <self:RapidTypeAnalysis>*/;
1369 var98 = ((val* (*)(val*, val*, val*, val*, val*))(var90->class->vft[COLOR_modelbuilder__ModelBuilder__force_get_primitive_method]))(var90, var_node, var92, var96, var97) /* force_get_primitive_method on <var90:ModelBuilder>*/;
1370 ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_monomorphic_send]))(var_v, var_vararg, var98) /* add_monomorphic_send on <var_v:RapidTypeVisitor>*/;
1371 } else {
1372 }
1373 var99 = NEW_range__Range(&type_range__Rangekernel__Int);
1374 var100 = 0;
1375 var101 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MMethodDef__msignature]))(var_mmethoddef) /* msignature on <var_mmethoddef:MMethodDef>*/;
1376 if (var101 == NULL) {
1377 fprintf(stderr, "Runtime error: %s", "Receiver is null");
1378 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 183);
1379 show_backtrace(1);
1380 } else {
1381 var102 = ((long (*)(val*))(var101->class->vft[COLOR_model__MSignature__arity]))(var101) /* arity on <var101:nullable MSignature>*/;
1382 }
1383 var103 = BOX_kernel__Int(var100); /* autobox from Int to Discrete */
1384 var104 = BOX_kernel__Int(var102); /* autobox from Int to Discrete */
1385 ((void (*)(val*, val*, val*))(var99->class->vft[COLOR_range__Range__without_last]))(var99, var103, var104) /* without_last on <var99:Range[Int]>*/;
1386 var105 = ((val* (*)(val*))(var99->class->vft[COLOR_abstract_collection__Collection__iterator]))(var99) /* iterator on <var99:Range[Int]>*/;
1387 for(;;) {
1388 var106 = ((short int (*)(val*))(var105->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var105) /* is_ok on <var105:Iterator[nullable Object]>*/;
1389 if(!var106) break;
1390 var107 = ((val* (*)(val*))(var105->class->vft[COLOR_abstract_collection__Iterator__item]))(var105) /* item on <var105:Iterator[nullable Object]>*/;
1391 var108 = ((struct instance_kernel__Int*)var107)->value; /* autounbox from nullable Object to Int */;
1392 var_i = var108;
1393 var109 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MPropDef__mproperty]))(var_mmethoddef) /* mproperty on <var_mmethoddef:MMethodDef>*/;
1394 var110 = ((val* (*)(val*))(var109->class->vft[COLOR_model__MProperty__intro]))(var109) /* intro on <var109:MProperty(MMethod)>*/;
1395 var111 = ((val* (*)(val*))(var110->class->vft[COLOR_model__MMethodDef__msignature]))(var110) /* msignature on <var110:MPropDef(MMethodDef)>*/;
1396 if (var111 == NULL) {
1397 fprintf(stderr, "Runtime error: %s", "Receiver is null");
1398 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 184);
1399 show_backtrace(1);
1400 } else {
1401 var112 = ((val* (*)(val*))(var111->class->vft[COLOR_model__MSignature__mparameters]))(var111) /* mparameters on <var111:nullable MSignature>*/;
1402 }
1403 var113 = ((val* (*)(val*, long))(var112->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var112, var_i) /* [] on <var112:Array[MParameter]>*/;
1404 var114 = ((val* (*)(val*))(var113->class->vft[COLOR_model__MParameter__mtype]))(var113) /* mtype on <var113:nullable Object(MParameter)>*/;
1405 var_origtype = var114;
1406 var115 = ((short int (*)(val*))(var_origtype->class->vft[COLOR_model__MType__need_anchor]))(var_origtype) /* need_anchor on <var_origtype:MType>*/;
1407 var116 = !var115;
1408 if (var116){
1409 goto CONTINUE_label;
1410 } else {
1411 }
1412 var117 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MMethodDef__msignature]))(var_mmethoddef) /* msignature on <var_mmethoddef:MMethodDef>*/;
1413 if (var117 == NULL) {
1414 fprintf(stderr, "Runtime error: %s", "Receiver is null");
1415 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 186);
1416 show_backtrace(1);
1417 } else {
1418 var118 = ((val* (*)(val*))(var117->class->vft[COLOR_model__MSignature__mparameters]))(var117) /* mparameters on <var117:nullable MSignature>*/;
1419 }
1420 var119 = ((val* (*)(val*, long))(var118->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var118, var_i) /* [] on <var118:Array[MParameter]>*/;
1421 var120 = ((val* (*)(val*))(var119->class->vft[COLOR_model__MParameter__mtype]))(var119) /* mtype on <var119:nullable Object(MParameter)>*/;
1422 var_paramtype = var120;
1423 ((void (*)(val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__add_cast]))(self, var_paramtype) /* add_cast on <self:RapidTypeAnalysis>*/;
1424 CONTINUE_label: (void)0;
1425 ((void (*)(val*))(var105->class->vft[COLOR_abstract_collection__Iterator__next]))(var105) /* next on <var105:Iterator[nullable Object]>*/;
1426 }
1427 BREAK_label: (void)0;
1428 var121 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__modelbuilder]))(self) /* modelbuilder on <self:RapidTypeAnalysis>*/;
1429 var122 = ((val* (*)(val*))(var121->class->vft[COLOR_modelize_property__ModelBuilder__mpropdef2npropdef]))(var121) /* mpropdef2npropdef on <var121:ModelBuilder>*/;
1430 var123 = ((short int (*)(val*, val*))(var122->class->vft[COLOR_abstract_collection__MapRead__has_key]))(var122, var_mmethoddef) /* has_key on <var122:HashMap[MPropDef, APropdef]>*/;
1431 var124 = !var123;
1432 if (var124){
1433 var125 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MPropDef__mproperty]))(var_mmethoddef) /* mproperty on <var_mmethoddef:MMethodDef>*/;
1434 var126 = ((val* (*)(val*))(var125->class->vft[COLOR_model__MProperty__name]))(var125) /* name on <var125:MProperty(MMethod)>*/;
1435 if (varonce127) {
1436 var128 = varonce127;
1437 } else {
1438 var129 = "init";
1439 var130 = 4;
1440 var131 = string__NativeString__to_s_with_length(var129, var130);
1441 var128 = var131;
1442 varonce127 = var128;
1443 }
1444 var132 = ((short int (*)(val*, val*))(var126->class->vft[COLOR_kernel__Object___61d_61d]))(var126, var128) /* == on <var126:String>*/;
1445 if (var132){
1446 var133 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__modelbuilder]))(self) /* modelbuilder on <self:RapidTypeAnalysis>*/;
1447 var134 = ((val* (*)(val*))(var133->class->vft[COLOR_modelize_class__ModelBuilder__mclassdef2nclassdef]))(var133) /* mclassdef2nclassdef on <var133:ModelBuilder>*/;
1448 var135 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MPropDef__mclassdef]))(var_mmethoddef) /* mclassdef on <var_mmethoddef:MMethodDef>*/;
1449 var136 = ((val* (*)(val*, val*))(var134->class->vft[COLOR_abstract_collection__MapRead___91d_93d]))(var134, var135) /* [] on <var134:HashMap[MClassDef, AClassdef]>*/;
1450 var_nclassdef = var136;
1451 var137 = ((val* (*)(val*))(var_nclassdef->class->vft[COLOR_modelize_property__AClassdef__super_inits]))(var_nclassdef) /* super_inits on <var_nclassdef:AClassdef>*/;
1452 var_super_inits = var137;
1453 var138 = NULL;
1454 if (var_super_inits == NULL) {
1455 var139 = 0; /* is null */
1456 } else {
1457 var139 = 1; /* arg is null and recv is not */
1458 }
1459 if (var139){
1460 var140 = ((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])>*/;
1461 for(;;) {
1462 var141 = ((short int (*)(val*))(var140->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var140) /* is_ok on <var140:Iterator[nullable Object]>*/;
1463 if(!var141) break;
1464 var142 = ((val* (*)(val*))(var140->class->vft[COLOR_abstract_collection__Iterator__item]))(var140) /* item on <var140:Iterator[nullable Object]>*/;
1465 var_su = var142;
1466 var143 = ((val* (*)(val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__receiver]))(var_v) /* receiver on <var_v:RapidTypeVisitor>*/;
1467 ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_monomorphic_send]))(var_v, var143, var_su) /* add_monomorphic_send on <var_v:RapidTypeVisitor>*/;
1468 CONTINUE_label144: (void)0;
1469 ((void (*)(val*))(var140->class->vft[COLOR_abstract_collection__Iterator__next]))(var140) /* next on <var140:Iterator[nullable Object]>*/;
1470 }
1471 BREAK_label144: (void)0;
1472 } else {
1473 }
1474 } else {
1475 fprintf(stderr, "Runtime error: %s", "Aborted");
1476 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 204);
1477 show_backtrace(1);
1478 }
1479 goto CONTINUE_label145;
1480 } else {
1481 }
1482 var146 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__modelbuilder]))(self) /* modelbuilder on <self:RapidTypeAnalysis>*/;
1483 var147 = ((val* (*)(val*))(var146->class->vft[COLOR_modelize_property__ModelBuilder__mpropdef2npropdef]))(var146) /* mpropdef2npropdef on <var146:ModelBuilder>*/;
1484 var148 = ((val* (*)(val*, val*))(var147->class->vft[COLOR_abstract_collection__MapRead___91d_93d]))(var147, var_mmethoddef) /* [] on <var147:HashMap[MPropDef, APropdef]>*/;
1485 var_npropdef = var148;
1486 /* <var_npropdef:APropdef> isa AConcreteMethPropdef */
1487 cltype150 = type_parser_nodes__AConcreteMethPropdef.color;
1488 idtype151 = type_parser_nodes__AConcreteMethPropdef.id;
1489 if(cltype150 >= var_npropdef->type->table_size) {
1490 var149 = 0;
1491 } else {
1492 var149 = var_npropdef->type->type_table[cltype150] == idtype151;
1493 }
1494 if (var149){
1495 var152 = ((val* (*)(val*))(var_npropdef->class->vft[COLOR_auto_super_init__AConcreteMethPropdef__auto_super_inits]))(var_npropdef) /* auto_super_inits on <var_npropdef:APropdef(AConcreteMethPropdef)>*/;
1496 var_auto_super_inits = var152;
1497 var153 = NULL;
1498 if (var_auto_super_inits == NULL) {
1499 var154 = 0; /* is null */
1500 } else {
1501 var154 = 1; /* arg is null and recv is not */
1502 }
1503 if (var154){
1504 var155 = ((val* (*)(val*))(var_auto_super_inits->class->vft[COLOR_abstract_collection__Collection__iterator]))(var_auto_super_inits) /* iterator on <var_auto_super_inits:nullable Array[CallSite](Array[CallSite])>*/;
1505 for(;;) {
1506 var156 = ((short int (*)(val*))(var155->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var155) /* is_ok on <var155:Iterator[nullable Object]>*/;
1507 if(!var156) break;
1508 var157 = ((val* (*)(val*))(var155->class->vft[COLOR_abstract_collection__Iterator__item]))(var155) /* item on <var155:Iterator[nullable Object]>*/;
1509 var_auto_super_init = var157;
1510 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_callsite]))(var_v, var_auto_super_init) /* add_callsite on <var_v:RapidTypeVisitor>*/;
1511 CONTINUE_label158: (void)0;
1512 ((void (*)(val*))(var155->class->vft[COLOR_abstract_collection__Iterator__next]))(var155) /* next on <var155:Iterator[nullable Object]>*/;
1513 }
1514 BREAK_label158: (void)0;
1515 } else {
1516 }
1517 } else {
1518 /* <var_npropdef:APropdef> isa AInternMethPropdef */
1519 cltype161 = type_parser_nodes__AInternMethPropdef.color;
1520 idtype162 = type_parser_nodes__AInternMethPropdef.id;
1521 if(cltype161 >= var_npropdef->type->table_size) {
1522 var160 = 0;
1523 } else {
1524 var160 = var_npropdef->type->type_table[cltype161] == idtype162;
1525 }
1526 var_ = var160;
1527 if (var160){
1528 var159 = var_;
1529 } else {
1530 /* <var_npropdef:APropdef> isa AExternMethPropdef */
1531 cltype165 = type_parser_nodes__AExternMethPropdef.color;
1532 idtype166 = type_parser_nodes__AExternMethPropdef.id;
1533 if(cltype165 >= var_npropdef->type->table_size) {
1534 var164 = 0;
1535 } else {
1536 var164 = var_npropdef->type->type_table[cltype165] == idtype166;
1537 }
1538 var_167 = var164;
1539 if (var164){
1540 var168 = ((val* (*)(val*))(var_npropdef->class->vft[COLOR_parser_nodes__AExternPropdef__n_extern]))(var_npropdef) /* n_extern on <var_npropdef:APropdef(AExternMethPropdef)>*/;
1541 var169 = NULL;
1542 if (var168 == NULL) {
1543 var170 = 0; /* is null */
1544 } else {
1545 var170 = 1; /* arg is null and recv is not */
1546 }
1547 var163 = var170;
1548 } else {
1549 var163 = var_167;
1550 }
1551 var159 = var163;
1552 }
1553 if (var159){
1554 var171 = ((val* (*)(val*))(var_mmethoddef->class->vft[COLOR_model__MMethodDef__msignature]))(var_mmethoddef) /* msignature on <var_mmethoddef:MMethodDef>*/;
1555 if (var171 == NULL) {
1556 fprintf(stderr, "Runtime error: %s", "Receiver is null");
1557 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 221);
1558 show_backtrace(1);
1559 } else {
1560 var172 = ((val* (*)(val*))(var171->class->vft[COLOR_model__MSignature__return_mtype]))(var171) /* return_mtype on <var171:nullable MSignature>*/;
1561 }
1562 var_ret = var172;
1563 var176 = NULL;
1564 if (var_ret == NULL) {
1565 var177 = 0; /* is null */
1566 } else {
1567 var177 = 1; /* arg is null and recv is not */
1568 }
1569 var_178 = var177;
1570 if (var177){
1571 /* <var_ret:nullable MType(MType)> isa MClassType */
1572 cltype180 = type_model__MClassType.color;
1573 idtype181 = type_model__MClassType.id;
1574 if(cltype180 >= var_ret->type->table_size) {
1575 var179 = 0;
1576 } else {
1577 var179 = var_ret->type->type_table[cltype180] == idtype181;
1578 }
1579 var175 = var179;
1580 } else {
1581 var175 = var_178;
1582 }
1583 var_182 = var175;
1584 if (var175){
1585 var183 = ((val* (*)(val*))(var_ret->class->vft[COLOR_model__MClassType__mclass]))(var_ret) /* mclass on <var_ret:nullable MType(MClassType)>*/;
1586 var184 = ((val* (*)(val*))(var183->class->vft[COLOR_model__MClass__kind]))(var183) /* kind on <var183:MClass>*/;
1587 var185 = ((val* (*)(val*))(self->class->vft[COLOR_model__Object__abstract_kind]))(self) /* abstract_kind on <self:RapidTypeAnalysis>*/;
1588 var186 = ((short int (*)(val*, val*))(var184->class->vft[COLOR_kernel__Object___33d_61d]))(var184, var185) /* != on <var184:MClassKind>*/;
1589 var174 = var186;
1590 } else {
1591 var174 = var_182;
1592 }
1593 var_187 = var174;
1594 if (var174){
1595 var188 = ((val* (*)(val*))(var_ret->class->vft[COLOR_model__MClassType__mclass]))(var_ret) /* mclass on <var_ret:nullable MType(MClassType)>*/;
1596 var189 = ((val* (*)(val*))(var188->class->vft[COLOR_model__MClass__kind]))(var188) /* kind on <var188:MClass>*/;
1597 var190 = ((val* (*)(val*))(self->class->vft[COLOR_model__Object__interface_kind]))(self) /* interface_kind on <self:RapidTypeAnalysis>*/;
1598 var191 = ((short int (*)(val*, val*))(var189->class->vft[COLOR_kernel__Object___33d_61d]))(var189, var190) /* != on <var189:MClassKind>*/;
1599 var173 = var191;
1600 } else {
1601 var173 = var_187;
1602 }
1603 if (var173){
1604 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var_ret) /* add_type on <var_v:RapidTypeVisitor>*/;
1605 } else {
1606 }
1607 } else {
1608 /* <var_npropdef:APropdef> isa AExternMethPropdef */
1609 cltype193 = type_parser_nodes__AExternMethPropdef.color;
1610 idtype194 = type_parser_nodes__AExternMethPropdef.id;
1611 if(cltype193 >= var_npropdef->type->table_size) {
1612 var192 = 0;
1613 } else {
1614 var192 = var_npropdef->type->type_table[cltype193] == idtype194;
1615 }
1616 if (var192){
1617 var195 = ((val* (*)(val*))(var_npropdef->class->vft[COLOR_parser_nodes__ANode__parent]))(var_npropdef) /* parent on <var_npropdef:APropdef(AExternMethPropdef)>*/;
1618 /* <var195:nullable ANode> isa AClassdef */
1619 cltype197 = type_parser_nodes__AClassdef.color;
1620 idtype198 = type_parser_nodes__AClassdef.id;
1621 if(var195 == NULL) {
1622 var196 = 0;
1623 } else {
1624 if(cltype197 >= var195->type->table_size) {
1625 var196 = 0;
1626 } else {
1627 var196 = var195->type->type_table[cltype197] == idtype198;
1628 }
1629 }
1630 if (!var196) {
1631 var_class_name199 = var195 == NULL ? "null" : var195->type->name;
1632 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "AClassdef", var_class_name199);
1633 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 226);
1634 show_backtrace(1);
1635 }
1636 var_nclassdef200 = var195;
1637 ((void (*)(val*, val*))(var_v->class->vft[COLOR_parser_nodes__Visitor__enter_visit]))(var_v, var_npropdef) /* enter_visit on <var_v:RapidTypeVisitor>*/;
1638 } else {
1639 /* <var_npropdef:APropdef> isa AExternInitPropdef */
1640 cltype202 = type_parser_nodes__AExternInitPropdef.color;
1641 idtype203 = type_parser_nodes__AExternInitPropdef.id;
1642 if(cltype202 >= var_npropdef->type->table_size) {
1643 var201 = 0;
1644 } else {
1645 var201 = var_npropdef->type->type_table[cltype202] == idtype203;
1646 }
1647 if (var201){
1648 var204 = ((val* (*)(val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__receiver]))(var_v) /* receiver on <var_v:RapidTypeVisitor>*/;
1649 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var204) /* add_type on <var_v:RapidTypeVisitor>*/;
1650 } else {
1651 }
1652 }
1653 }
1654 }
1655 ((void (*)(val*, val*))(var_v->class->vft[COLOR_parser_nodes__Visitor__enter_visit]))(var_v, var_npropdef) /* enter_visit on <var_v:RapidTypeVisitor>*/;
1656 CONTINUE_label145: (void)0;
1657 }
1658 BREAK_label145: (void)0;
1659 var205 = NEW_list__List(&type_list__Listmodel__MClassType);
1660 ((void (*)(val*))(var205->class->vft[COLOR_list__List__init]))(var205) /* init on <var205:List[MClassType]>*/;
1661 var_todo_types = var205;
1662 var206 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_types]))(self) /* live_types on <self:RapidTypeAnalysis>*/;
1663 ((void (*)(val*, val*))(var_todo_types->class->vft[COLOR_abstract_collection__SimpleCollection__add_all]))(var_todo_types, var206) /* add_all on <var_todo_types:List[MClassType]>*/;
1664 for(;;) {
1665 var207 = ((short int (*)(val*))(var_todo_types->class->vft[COLOR_abstract_collection__Collection__is_empty]))(var_todo_types) /* is_empty on <var_todo_types:List[MClassType]>*/;
1666 var208 = !var207;
1667 if (!var208) break;
1668 var209 = ((val* (*)(val*))(var_todo_types->class->vft[COLOR_abstract_collection__Sequence__shift]))(var_todo_types) /* shift on <var_todo_types:List[MClassType]>*/;
1669 var_t = var209;
1670 var210 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_open_types]))(self) /* live_open_types on <self:RapidTypeAnalysis>*/;
1671 var211 = ((val* (*)(val*))(var210->class->vft[COLOR_abstract_collection__Collection__iterator]))(var210) /* iterator on <var210:HashSet[MClassType]>*/;
1672 for(;;) {
1673 var212 = ((short int (*)(val*))(var211->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var211) /* is_ok on <var211:Iterator[nullable Object]>*/;
1674 if(!var212) break;
1675 var213 = ((val* (*)(val*))(var211->class->vft[COLOR_abstract_collection__Iterator__item]))(var211) /* item on <var211:Iterator[nullable Object]>*/;
1676 var_ot = var213;
1677 var214 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on <self:RapidTypeAnalysis>*/;
1678 var215 = ((short int (*)(val*, val*, val*, val*))(var_ot->class->vft[COLOR_model__MType__can_resolve_for]))(var_ot, var_t, var_t, var214) /* can_resolve_for on <var_ot:MClassType>*/;
1679 var216 = !var215;
1680 if (var216){
1681 goto CONTINUE_label217;
1682 } else {
1683 }
1684 var218 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on <self:RapidTypeAnalysis>*/;
1685 var219 = ((val* (*)(val*, val*, val*))(var_ot->class->vft[COLOR_model__MType__anchor_to]))(var_ot, var218, var_t) /* anchor_to on <var_ot:MClassType>*/;
1686 var_rt = var219;
1687 var220 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_types]))(self) /* live_types on <self:RapidTypeAnalysis>*/;
1688 var221 = ((short int (*)(val*, val*))(var220->class->vft[COLOR_abstract_collection__Collection__has]))(var220, var_rt) /* has on <var220:HashSet[MClassType]>*/;
1689 if (var221){
1690 goto CONTINUE_label217;
1691 } else {
1692 }
1693 var222 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_types]))(self) /* live_types on <self:RapidTypeAnalysis>*/;
1694 ((void (*)(val*, val*))(var222->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var222, var_rt) /* add on <var222:HashSet[MClassType]>*/;
1695 ((void (*)(val*, val*))(var_todo_types->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_todo_types, var_rt) /* add on <var_todo_types:List[MClassType]>*/;
1696 ((void (*)(val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__check_depth]))(self, var_rt) /* check_depth on <self:RapidTypeAnalysis>*/;
1697 CONTINUE_label217: (void)0;
1698 ((void (*)(val*))(var211->class->vft[COLOR_abstract_collection__Iterator__next]))(var211) /* next on <var211:Iterator[nullable Object]>*/;
1699 }
1700 BREAK_label217: (void)0;
1701 CONTINUE_label223: (void)0;
1702 }
1703 BREAK_label223: (void)0;
1704 var224 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_open_cast_types]))(self) /* live_open_cast_types on <self:RapidTypeAnalysis>*/;
1705 var225 = ((val* (*)(val*))(var224->class->vft[COLOR_abstract_collection__Collection__iterator]))(var224) /* iterator on <var224:HashSet[MType]>*/;
1706 for(;;) {
1707 var226 = ((short int (*)(val*))(var225->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var225) /* is_ok on <var225:Iterator[nullable Object]>*/;
1708 if(!var226) break;
1709 var227 = ((val* (*)(val*))(var225->class->vft[COLOR_abstract_collection__Iterator__item]))(var225) /* item on <var225:Iterator[nullable Object]>*/;
1710 var_ot228 = var227;
1711 var229 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_types]))(self) /* live_types on <self:RapidTypeAnalysis>*/;
1712 var230 = ((val* (*)(val*))(var229->class->vft[COLOR_abstract_collection__Collection__iterator]))(var229) /* iterator on <var229:HashSet[MClassType]>*/;
1713 for(;;) {
1714 var231 = ((short int (*)(val*))(var230->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var230) /* is_ok on <var230:Iterator[nullable Object]>*/;
1715 if(!var231) break;
1716 var232 = ((val* (*)(val*))(var230->class->vft[COLOR_abstract_collection__Iterator__item]))(var230) /* item on <var230:Iterator[nullable Object]>*/;
1717 var_t233 = var232;
1718 var234 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on <self:RapidTypeAnalysis>*/;
1719 var235 = ((short int (*)(val*, val*, val*, val*))(var_ot228->class->vft[COLOR_model__MType__can_resolve_for]))(var_ot228, var_t233, var_t233, var234) /* can_resolve_for on <var_ot228:MType>*/;
1720 var236 = !var235;
1721 if (var236){
1722 goto CONTINUE_label237;
1723 } else {
1724 }
1725 var238 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on <self:RapidTypeAnalysis>*/;
1726 var239 = ((val* (*)(val*, val*, val*))(var_ot228->class->vft[COLOR_model__MType__anchor_to]))(var_ot228, var238, var_t233) /* anchor_to on <var_ot228:MType>*/;
1727 var_rt240 = var239;
1728 var241 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_cast_types]))(self) /* live_cast_types on <self:RapidTypeAnalysis>*/;
1729 ((void (*)(val*, val*))(var241->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var241, var_rt240) /* add on <var241:HashSet[MType]>*/;
1730 CONTINUE_label237: (void)0;
1731 ((void (*)(val*))(var230->class->vft[COLOR_abstract_collection__Iterator__next]))(var230) /* next on <var230:Iterator[nullable Object]>*/;
1732 }
1733 BREAK_label237: (void)0;
1734 CONTINUE_label242: (void)0;
1735 ((void (*)(val*))(var225->class->vft[COLOR_abstract_collection__Iterator__next]))(var225) /* next on <var225:Iterator[nullable Object]>*/;
1736 }
1737 BREAK_label242: (void)0;
1738 RET_LABEL:;
1739 }
1740 /* method rapid_type_analysis#RapidTypeAnalysis#run_analysis for (self: Object) */
1741 void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__run_analysis(val* self) {
1742 rapid_type_analysis__RapidTypeAnalysis__run_analysis(self);
1743 RET_LABEL:;
1744 }
1745 /* method rapid_type_analysis#RapidTypeAnalysis#check_depth for (self: RapidTypeAnalysis, MClassType) */
1746 void rapid_type_analysis__RapidTypeAnalysis__check_depth(val* self, val* p0) {
1747 val* var_mtype /* var mtype: MClassType */;
1748 long var /* : Int */;
1749 long var_d /* var d: Int */;
1750 long var1 /* : Int */;
1751 short int var2 /* : Bool */;
1752 short int var4 /* : Bool */;
1753 int cltype;
1754 int idtype;
1755 const char* var_class_name;
1756 short int var5 /* : Bool */;
1757 val* var6 /* : ModelBuilder */;
1758 val* var7 /* : ToolContext */;
1759 val* var8 /* : null */;
1760 static val* varonce;
1761 val* var9 /* : String */;
1762 char* var10 /* : NativeString */;
1763 long var11 /* : Int */;
1764 val* var12 /* : String */;
1765 static val* varonce13;
1766 val* var14 /* : String */;
1767 char* var15 /* : NativeString */;
1768 long var16 /* : Int */;
1769 val* var17 /* : String */;
1770 static val* varonce18;
1771 val* var19 /* : String */;
1772 char* var20 /* : NativeString */;
1773 long var21 /* : Int */;
1774 val* var22 /* : String */;
1775 val* var23 /* : Array[Object] */;
1776 long var24 /* : Int */;
1777 val* var25 /* : NativeArray[Object] */;
1778 val* var26 /* : Object */;
1779 val* var27 /* : String */;
1780 var_mtype = p0;
1781 var = ((long (*)(val*))(var_mtype->class->vft[COLOR_model__MType__length]))(var_mtype) /* length on <var_mtype:MClassType>*/;
1782 var_d = var;
1783 var1 = 255;
1784 { /* Inline kernel#Int#> (var_d,var1) */
1785 /* Covariant cast for argument 0 (i) <var1:Int> isa OTHER */
1786 /* <var1:Int> isa OTHER */
1787 var4 = 1; /* easy <var1:Int> isa OTHER*/
1788 if (!var4) {
1789 var_class_name = type_kernel__Int.name;
1790 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
1791 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 267);
1792 show_backtrace(1);
1793 }
1794 var5 = var_d > var1;
1795 var2 = var5;
1796 goto RET_LABEL3;
1797 RET_LABEL3:(void)0;
1798 }
1799 if (var2){
1800 var6 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__modelbuilder]))(self) /* modelbuilder on <self:RapidTypeAnalysis>*/;
1801 var7 = ((val* (*)(val*))(var6->class->vft[COLOR_modelbuilder__ModelBuilder__toolcontext]))(var6) /* toolcontext on <var6:ModelBuilder>*/;
1802 var8 = NULL;
1803 if (varonce) {
1804 var9 = varonce;
1805 } else {
1806 var10 = "Fatal error: limitation in the rapidtype analysis engine: a type depth of ";
1807 var11 = 74;
1808 var12 = string__NativeString__to_s_with_length(var10, var11);
1809 var9 = var12;
1810 varonce = var9;
1811 }
1812 if (varonce13) {
1813 var14 = varonce13;
1814 } else {
1815 var15 = " is too important, the problematic type is ";
1816 var16 = 43;
1817 var17 = string__NativeString__to_s_with_length(var15, var16);
1818 var14 = var17;
1819 varonce13 = var14;
1820 }
1821 if (varonce18) {
1822 var19 = varonce18;
1823 } else {
1824 var20 = ".";
1825 var21 = 1;
1826 var22 = string__NativeString__to_s_with_length(var20, var21);
1827 var19 = var22;
1828 varonce18 = var19;
1829 }
1830 var23 = NEW_array__Array(&type_array__Arraykernel__Object);
1831 { /* var23 = array_instance Array[Object] */
1832 var24 = 5;
1833 var25 = NEW_array__NativeArray(var24, &type_array__NativeArraykernel__Object);
1834 ((struct instance_array__NativeArray*)var25)->values[0] = (val*) var9;
1835 var26 = BOX_kernel__Int(var_d); /* autobox from Int to Object */
1836 ((struct instance_array__NativeArray*)var25)->values[1] = (val*) var26;
1837 ((struct instance_array__NativeArray*)var25)->values[2] = (val*) var14;
1838 ((struct instance_array__NativeArray*)var25)->values[3] = (val*) var_mtype;
1839 ((struct instance_array__NativeArray*)var25)->values[4] = (val*) var19;
1840 ((void (*)(val*, val*, long))(var23->class->vft[COLOR_array__Array__with_native]))(var23, var25, var24) /* with_native on <var23:Array[Object]>*/;
1841 }
1842 var27 = ((val* (*)(val*))(var23->class->vft[COLOR_string__Object__to_s]))(var23) /* to_s on <var23:Array[Object]>*/;
1843 ((void (*)(val*, val*, val*))(var7->class->vft[COLOR_toolcontext__ToolContext__fatal_error]))(var7, var8, var27) /* fatal_error on <var7:ToolContext>*/;
1844 } else {
1845 }
1846 RET_LABEL:;
1847 }
1848 /* method rapid_type_analysis#RapidTypeAnalysis#check_depth for (self: Object, MClassType) */
1849 void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__check_depth(val* self, val* p0) {
1850 rapid_type_analysis__RapidTypeAnalysis__check_depth(self, p0);
1851 RET_LABEL:;
1852 }
1853 /* method rapid_type_analysis#RapidTypeAnalysis#add_new for (self: RapidTypeAnalysis, MClassType, MClassType) */
1854 void rapid_type_analysis__RapidTypeAnalysis__add_new(val* self, val* p0, val* p1) {
1855 val* var_recv /* var recv: MClassType */;
1856 val* var_mtype /* var mtype: MClassType */;
1857 short int var /* : Bool */;
1858 short int var1 /* : Bool */;
1859 short int var2 /* : Bool */;
1860 val* var3 /* : HashSet[MClassType] */;
1861 short int var4 /* : Bool */;
1862 val* var5 /* : HashSet[MClassType] */;
1863 val* var6 /* : HashSet[MClassType] */;
1864 short int var7 /* : Bool */;
1865 val* var8 /* : HashSet[MClassType] */;
1866 val* var9 /* : MClass */;
1867 val* var_mclass /* var mclass: MClass */;
1868 val* var10 /* : HashSet[MClass] */;
1869 short int var11 /* : Bool */;
1870 val* var12 /* : HashSet[MClass] */;
1871 val* var13 /* : HashSet[MMethod] */;
1872 val* var14 /* : Iterator[nullable Object] */;
1873 short int var15 /* : Bool */;
1874 val* var16 /* : nullable Object */;
1875 val* var_p /* var p: MMethod */;
1876 val* var17 /* : HashSet[MMethodDef] */;
1877 val* var18 /* : Iterator[nullable Object] */;
1878 short int var19 /* : Bool */;
1879 val* var20 /* : nullable Object */;
1880 val* var_p21 /* var p: MMethodDef */;
1881 val* var23 /* : MModule */;
1882 val* var24 /* : MType */;
1883 val* var_bound_mtype /* var bound_mtype: MClassType */;
1884 val* var25 /* : MModule */;
1885 val* var26 /* : Set[MClassDef] */;
1886 val* var27 /* : Iterator[nullable Object] */;
1887 short int var28 /* : Bool */;
1888 val* var29 /* : nullable Object */;
1889 val* var_cd /* var cd: MClassDef */;
1890 val* var30 /* : ModelBuilder */;
1891 val* var31 /* : HashMap[MClassDef, AClassdef] */;
1892 short int var32 /* : Bool */;
1893 short int var33 /* : Bool */;
1894 val* var35 /* : ModelBuilder */;
1895 val* var36 /* : HashMap[MClassDef, AClassdef] */;
1896 val* var37 /* : nullable Object */;
1897 val* var_nclassdef /* var nclassdef: AClassdef */;
1898 val* var38 /* : ANodes[APropdef] */;
1899 val* var39 /* : Iterator[nullable Object] */;
1900 short int var40 /* : Bool */;
1901 val* var41 /* : nullable Object */;
1902 val* var_npropdef /* var npropdef: APropdef */;
1903 short int var42 /* : Bool */;
1904 int cltype;
1905 int idtype;
1906 short int var43 /* : Bool */;
1907 val* var45 /* : nullable AExpr */;
1908 val* var_nexpr /* var nexpr: nullable AExpr */;
1909 val* var46 /* : null */;
1910 short int var47 /* : Bool */;
1911 val* var48 /* : nullable MPropDef */;
1912 val* var_mpropdef /* var mpropdef: MAttributeDef */;
1913 val* var49 /* : RapidTypeVisitor */;
1914 val* var_v /* var v: RapidTypeVisitor */;
1915 var_recv = p0;
1916 var_mtype = p1;
1917 var = ((short int (*)(val*))(var_recv->class->vft[COLOR_model__MType__need_anchor]))(var_recv) /* need_anchor on <var_recv:MClassType>*/;
1918 var1 = !var;
1919 if (!var1) {
1920 fprintf(stderr, "Runtime error: %s", "Assert failed");
1921 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 281);
1922 show_backtrace(1);
1923 }
1924 var2 = ((short int (*)(val*))(var_mtype->class->vft[COLOR_model__MType__need_anchor]))(var_mtype) /* need_anchor on <var_mtype:MClassType>*/;
1925 if (var2){
1926 var3 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_open_types]))(self) /* live_open_types on <self:RapidTypeAnalysis>*/;
1927 var4 = ((short int (*)(val*, val*))(var3->class->vft[COLOR_abstract_collection__Collection__has]))(var3, var_mtype) /* has on <var3:HashSet[MClassType]>*/;
1928 if (var4){
1929 goto RET_LABEL;
1930 } else {
1931 }
1932 var5 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_open_types]))(self) /* live_open_types on <self:RapidTypeAnalysis>*/;
1933 ((void (*)(val*, val*))(var5->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var5, var_mtype) /* add on <var5:HashSet[MClassType]>*/;
1934 } else {
1935 var6 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_types]))(self) /* live_types on <self:RapidTypeAnalysis>*/;
1936 var7 = ((short int (*)(val*, val*))(var6->class->vft[COLOR_abstract_collection__Collection__has]))(var6, var_mtype) /* has on <var6:HashSet[MClassType]>*/;
1937 if (var7){
1938 goto RET_LABEL;
1939 } else {
1940 }
1941 var8 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_types]))(self) /* live_types on <self:RapidTypeAnalysis>*/;
1942 ((void (*)(val*, val*))(var8->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var8, var_mtype) /* add on <var8:HashSet[MClassType]>*/;
1943 }
1944 var9 = ((val* (*)(val*))(var_mtype->class->vft[COLOR_model__MClassType__mclass]))(var_mtype) /* mclass on <var_mtype:MClassType>*/;
1945 var_mclass = var9;
1946 var10 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_classes]))(self) /* live_classes on <self:RapidTypeAnalysis>*/;
1947 var11 = ((short int (*)(val*, val*))(var10->class->vft[COLOR_abstract_collection__Collection__has]))(var10, var_mclass) /* has on <var10:HashSet[MClass]>*/;
1948 if (var11){
1949 goto RET_LABEL;
1950 } else {
1951 }
1952 var12 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_classes]))(self) /* live_classes on <self:RapidTypeAnalysis>*/;
1953 ((void (*)(val*, val*))(var12->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var12, var_mclass) /* add on <var12:HashSet[MClass]>*/;
1954 var13 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__totry_methods]))(self) /* totry_methods on <self:RapidTypeAnalysis>*/;
1955 var14 = ((val* (*)(val*))(var13->class->vft[COLOR_abstract_collection__Collection__iterator]))(var13) /* iterator on <var13:HashSet[MMethod]>*/;
1956 for(;;) {
1957 var15 = ((short int (*)(val*))(var14->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var14) /* is_ok on <var14:Iterator[nullable Object]>*/;
1958 if(!var15) break;
1959 var16 = ((val* (*)(val*))(var14->class->vft[COLOR_abstract_collection__Iterator__item]))(var14) /* item on <var14:Iterator[nullable Object]>*/;
1960 var_p = var16;
1961 ((void (*)(val*, val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__try_send]))(self, var_mtype, var_p) /* try_send on <self:RapidTypeAnalysis>*/;
1962 CONTINUE_label: (void)0;
1963 ((void (*)(val*))(var14->class->vft[COLOR_abstract_collection__Iterator__next]))(var14) /* next on <var14:Iterator[nullable Object]>*/;
1964 }
1965 BREAK_label: (void)0;
1966 var17 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_super_sends]))(self) /* live_super_sends on <self:RapidTypeAnalysis>*/;
1967 var18 = ((val* (*)(val*))(var17->class->vft[COLOR_abstract_collection__Collection__iterator]))(var17) /* iterator on <var17:HashSet[MMethodDef]>*/;
1968 for(;;) {
1969 var19 = ((short int (*)(val*))(var18->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var18) /* is_ok on <var18:Iterator[nullable Object]>*/;
1970 if(!var19) break;
1971 var20 = ((val* (*)(val*))(var18->class->vft[COLOR_abstract_collection__Iterator__item]))(var18) /* item on <var18:Iterator[nullable Object]>*/;
1972 var_p21 = var20;
1973 ((void (*)(val*, val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__try_super_send]))(self, var_mtype, var_p21) /* try_super_send on <self:RapidTypeAnalysis>*/;
1974 CONTINUE_label22: (void)0;
1975 ((void (*)(val*))(var18->class->vft[COLOR_abstract_collection__Iterator__next]))(var18) /* next on <var18:Iterator[nullable Object]>*/;
1976 }
1977 BREAK_label22: (void)0;
1978 var23 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on <self:RapidTypeAnalysis>*/;
1979 var24 = ((val* (*)(val*, val*, val*))(var_mtype->class->vft[COLOR_model__MType__anchor_to]))(var_mtype, var23, var_recv) /* anchor_to on <var_mtype:MClassType>*/;
1980 var_bound_mtype = var24;
1981 var25 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on <self:RapidTypeAnalysis>*/;
1982 var26 = ((val* (*)(val*, val*))(var_bound_mtype->class->vft[COLOR_model__MType__collect_mclassdefs]))(var_bound_mtype, var25) /* collect_mclassdefs on <var_bound_mtype:MClassType>*/;
1983 var27 = ((val* (*)(val*))(var26->class->vft[COLOR_abstract_collection__Collection__iterator]))(var26) /* iterator on <var26:Set[MClassDef]>*/;
1984 for(;;) {
1985 var28 = ((short int (*)(val*))(var27->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var27) /* is_ok on <var27:Iterator[nullable Object]>*/;
1986 if(!var28) break;
1987 var29 = ((val* (*)(val*))(var27->class->vft[COLOR_abstract_collection__Iterator__item]))(var27) /* item on <var27:Iterator[nullable Object]>*/;
1988 var_cd = var29;
1989 var30 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__modelbuilder]))(self) /* modelbuilder on <self:RapidTypeAnalysis>*/;
1990 var31 = ((val* (*)(val*))(var30->class->vft[COLOR_modelize_class__ModelBuilder__mclassdef2nclassdef]))(var30) /* mclassdef2nclassdef on <var30:ModelBuilder>*/;
1991 var32 = ((short int (*)(val*, val*))(var31->class->vft[COLOR_abstract_collection__MapRead__has_key]))(var31, var_cd) /* has_key on <var31:HashMap[MClassDef, AClassdef]>*/;
1992 var33 = !var32;
1993 if (var33){
1994 goto CONTINUE_label34;
1995 } else {
1996 }
1997 var35 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__modelbuilder]))(self) /* modelbuilder on <self:RapidTypeAnalysis>*/;
1998 var36 = ((val* (*)(val*))(var35->class->vft[COLOR_modelize_class__ModelBuilder__mclassdef2nclassdef]))(var35) /* mclassdef2nclassdef on <var35:ModelBuilder>*/;
1999 var37 = ((val* (*)(val*, val*))(var36->class->vft[COLOR_abstract_collection__MapRead___91d_93d]))(var36, var_cd) /* [] on <var36:HashMap[MClassDef, AClassdef]>*/;
2000 var_nclassdef = var37;
2001 var38 = ((val* (*)(val*))(var_nclassdef->class->vft[COLOR_parser_nodes__AClassdef__n_propdefs]))(var_nclassdef) /* n_propdefs on <var_nclassdef:AClassdef>*/;
2002 var39 = ((val* (*)(val*))(var38->class->vft[COLOR_abstract_collection__Collection__iterator]))(var38) /* iterator on <var38:ANodes[APropdef]>*/;
2003 for(;;) {
2004 var40 = ((short int (*)(val*))(var39->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var39) /* is_ok on <var39:Iterator[nullable Object]>*/;
2005 if(!var40) break;
2006 var41 = ((val* (*)(val*))(var39->class->vft[COLOR_abstract_collection__Iterator__item]))(var39) /* item on <var39:Iterator[nullable Object]>*/;
2007 var_npropdef = var41;
2008 /* <var_npropdef:APropdef> isa AAttrPropdef */
2009 cltype = type_parser_nodes__AAttrPropdef.color;
2010 idtype = type_parser_nodes__AAttrPropdef.id;
2011 if(cltype >= var_npropdef->type->table_size) {
2012 var42 = 0;
2013 } else {
2014 var42 = var_npropdef->type->type_table[cltype] == idtype;
2015 }
2016 var43 = !var42;
2017 if (var43){
2018 goto CONTINUE_label44;
2019 } else {
2020 }
2021 var45 = ((val* (*)(val*))(var_npropdef->class->vft[COLOR_parser_nodes__AAttrPropdef__n_expr]))(var_npropdef) /* n_expr on <var_npropdef:APropdef(AAttrPropdef)>*/;
2022 var_nexpr = var45;
2023 var46 = NULL;
2024 if (var_nexpr == NULL) {
2025 var47 = 1; /* is null */
2026 } else {
2027 var47 = 0; /* arg is null but recv is not */
2028 }
2029 if (var47){
2030 goto CONTINUE_label44;
2031 } else {
2032 }
2033 var48 = ((val* (*)(val*))(var_npropdef->class->vft[COLOR_modelize_property__APropdef__mpropdef]))(var_npropdef) /* mpropdef on <var_npropdef:APropdef(AAttrPropdef)>*/;
2034 if (var48 == NULL) {
2035 fprintf(stderr, "Runtime error: %s", "Cast failed");
2036 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 306);
2037 show_backtrace(1);
2038 }
2039 var_mpropdef = var48;
2040 var49 = NEW_rapid_type_analysis__RapidTypeVisitor(&type_rapid_type_analysis__RapidTypeVisitor);
2041 ((void (*)(val*, val*, val*, val*))(var49->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__init]))(var49, self, var_bound_mtype, var_mpropdef) /* init on <var49:RapidTypeVisitor>*/;
2042 var_v = var49;
2043 ((void (*)(val*, val*))(var_v->class->vft[COLOR_parser_nodes__Visitor__enter_visit]))(var_v, var_nexpr) /* enter_visit on <var_v:RapidTypeVisitor>*/;
2044 CONTINUE_label44: (void)0;
2045 ((void (*)(val*))(var39->class->vft[COLOR_abstract_collection__Iterator__next]))(var39) /* next on <var39:Iterator[nullable Object]>*/;
2046 }
2047 BREAK_label44: (void)0;
2048 CONTINUE_label34: (void)0;
2049 ((void (*)(val*))(var27->class->vft[COLOR_abstract_collection__Iterator__next]))(var27) /* next on <var27:Iterator[nullable Object]>*/;
2050 }
2051 BREAK_label34: (void)0;
2052 RET_LABEL:;
2053 }
2054 /* method rapid_type_analysis#RapidTypeAnalysis#add_new for (self: Object, MClassType, MClassType) */
2055 void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__add_new(val* self, val* p0, val* p1) {
2056 rapid_type_analysis__RapidTypeAnalysis__add_new(self, p0, p1);
2057 RET_LABEL:;
2058 }
2059 /* method rapid_type_analysis#RapidTypeAnalysis#add_cast for (self: RapidTypeAnalysis, MType) */
2060 void rapid_type_analysis__RapidTypeAnalysis__add_cast(val* self, val* p0) {
2061 val* var_mtype /* var mtype: MType */;
2062 short int var /* : Bool */;
2063 val* var1 /* : HashSet[MType] */;
2064 val* var2 /* : HashSet[MType] */;
2065 var_mtype = p0;
2066 var = ((short int (*)(val*))(var_mtype->class->vft[COLOR_model__MType__need_anchor]))(var_mtype) /* need_anchor on <var_mtype:MType>*/;
2067 if (var){
2068 var1 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_open_cast_types]))(self) /* live_open_cast_types on <self:RapidTypeAnalysis>*/;
2069 ((void (*)(val*, val*))(var1->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var1, var_mtype) /* add on <var1:HashSet[MType]>*/;
2070 } else {
2071 var2 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_cast_types]))(self) /* live_cast_types on <self:RapidTypeAnalysis>*/;
2072 ((void (*)(val*, val*))(var2->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var2, var_mtype) /* add on <var2:HashSet[MType]>*/;
2073 }
2074 RET_LABEL:;
2075 }
2076 /* method rapid_type_analysis#RapidTypeAnalysis#add_cast for (self: Object, MType) */
2077 void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__add_cast(val* self, val* p0) {
2078 rapid_type_analysis__RapidTypeAnalysis__add_cast(self, p0);
2079 RET_LABEL:;
2080 }
2081 /* method rapid_type_analysis#RapidTypeAnalysis#try_send for (self: RapidTypeAnalysis, MClassType, MMethod) */
2082 void rapid_type_analysis__RapidTypeAnalysis__try_send(val* self, val* p0, val* p1) {
2083 val* var_recv /* var recv: MClassType */;
2084 val* var_mproperty /* var mproperty: MMethod */;
2085 val* var /* : MClass */;
2086 val* var1 /* : MClassDef */;
2087 val* var2 /* : MClassType */;
2088 val* var3 /* : MModule */;
2089 short int var4 /* : Bool */;
2090 short int var5 /* : Bool */;
2091 val* var6 /* : MModule */;
2092 val* var7 /* : MPropDef */;
2093 val* var_d /* var d: MMethodDef */;
2094 var_recv = p0;
2095 var_mproperty = p1;
2096 var = ((val* (*)(val*))(var_recv->class->vft[COLOR_model__MClassType__mclass]))(var_recv) /* mclass on <var_recv:MClassType>*/;
2097 var1 = ((val* (*)(val*))(var->class->vft[COLOR_model__MClass__intro]))(var) /* intro on <var:MClass>*/;
2098 var2 = ((val* (*)(val*))(var1->class->vft[COLOR_model__MClassDef__bound_mtype]))(var1) /* bound_mtype on <var1:MClassDef>*/;
2099 var_recv = var2;
2100 var3 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on <self:RapidTypeAnalysis>*/;
2101 var4 = ((short int (*)(val*, val*, val*))(var_recv->class->vft[COLOR_model__MType__has_mproperty]))(var_recv, var3, var_mproperty) /* has_mproperty on <var_recv:MClassType>*/;
2102 var5 = !var4;
2103 if (var5){
2104 goto RET_LABEL;
2105 } else {
2106 }
2107 var6 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on <self:RapidTypeAnalysis>*/;
2108 var7 = ((val* (*)(val*, val*, val*))(var_mproperty->class->vft[COLOR_model__MProperty__lookup_first_definition]))(var_mproperty, var6, var_recv) /* lookup_first_definition on <var_mproperty:MMethod>*/;
2109 var_d = var7;
2110 ((void (*)(val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__add_call]))(self, var_d) /* add_call on <self:RapidTypeAnalysis>*/;
2111 RET_LABEL:;
2112 }
2113 /* method rapid_type_analysis#RapidTypeAnalysis#try_send for (self: Object, MClassType, MMethod) */
2114 void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__try_send(val* self, val* p0, val* p1) {
2115 rapid_type_analysis__RapidTypeAnalysis__try_send(self, p0, p1);
2116 RET_LABEL:;
2117 }
2118 /* method rapid_type_analysis#RapidTypeAnalysis#add_call for (self: RapidTypeAnalysis, MMethodDef) */
2119 void rapid_type_analysis__RapidTypeAnalysis__add_call(val* self, val* p0) {
2120 val* var_mpropdef /* var mpropdef: MMethodDef */;
2121 val* var /* : HashSet[MMethodDef] */;
2122 short int var1 /* : Bool */;
2123 val* var2 /* : HashSet[MMethodDef] */;
2124 val* var3 /* : List[MMethodDef] */;
2125 val* var4 /* : MProperty */;
2126 val* var_mproperty /* var mproperty: MMethod */;
2127 val* var5 /* : Array[MPropDef] */;
2128 long var6 /* : Int */;
2129 long var7 /* : Int */;
2130 short int var8 /* : Bool */;
2131 short int var10 /* : Bool */;
2132 int cltype;
2133 int idtype;
2134 const char* var_class_name;
2135 short int var11 /* : Bool */;
2136 val* var12 /* : Array[MPropDef] */;
2137 val* var13 /* : Iterator[nullable Object] */;
2138 short int var14 /* : Bool */;
2139 val* var15 /* : nullable Object */;
2140 val* var_d /* var d: MMethodDef */;
2141 short int var16 /* : Bool */;
2142 val* var17 /* : HashSet[MMethodDef] */;
2143 short int var18 /* : Bool */;
2144 short int var19 /* : Bool */;
2145 val* var20 /* : HashSet[MMethod] */;
2146 val* var21 /* : MProperty */;
2147 var_mpropdef = p0;
2148 var = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_methoddefs]))(self) /* live_methoddefs on <self:RapidTypeAnalysis>*/;
2149 var1 = ((short int (*)(val*, val*))(var->class->vft[COLOR_abstract_collection__Collection__has]))(var, var_mpropdef) /* has on <var:HashSet[MMethodDef]>*/;
2150 if (var1){
2151 goto RET_LABEL;
2152 } else {
2153 }
2154 var2 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_methoddefs]))(self) /* live_methoddefs on <self:RapidTypeAnalysis>*/;
2155 ((void (*)(val*, val*))(var2->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var2, var_mpropdef) /* add on <var2:HashSet[MMethodDef]>*/;
2156 var3 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__todo]))(self) /* todo on <self:RapidTypeAnalysis>*/;
2157 ((void (*)(val*, val*))(var3->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var3, var_mpropdef) /* add on <var3:List[MMethodDef]>*/;
2158 var4 = ((val* (*)(val*))(var_mpropdef->class->vft[COLOR_model__MPropDef__mproperty]))(var_mpropdef) /* mproperty on <var_mpropdef:MMethodDef>*/;
2159 var_mproperty = var4;
2160 var5 = ((val* (*)(val*))(var_mproperty->class->vft[COLOR_model__MProperty__mpropdefs]))(var_mproperty) /* mpropdefs on <var_mproperty:MMethod>*/;
2161 var6 = ((long (*)(val*))(var5->class->vft[COLOR_abstract_collection__Collection__length]))(var5) /* length on <var5:Array[MPropDef](Array[MMethodDef])>*/;
2162 var7 = 1;
2163 { /* Inline kernel#Int#<= (var6,var7) */
2164 /* Covariant cast for argument 0 (i) <var7:Int> isa OTHER */
2165 /* <var7:Int> isa OTHER */
2166 var10 = 1; /* easy <var7:Int> isa OTHER*/
2167 if (!var10) {
2168 var_class_name = type_kernel__Int.name;
2169 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
2170 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 264);
2171 show_backtrace(1);
2172 }
2173 var11 = var6 <= var7;
2174 var8 = var11;
2175 goto RET_LABEL9;
2176 RET_LABEL9:(void)0;
2177 }
2178 if (var8){
2179 goto RET_LABEL;
2180 } else {
2181 }
2182 var12 = ((val* (*)(val*))(var_mproperty->class->vft[COLOR_model__MProperty__mpropdefs]))(var_mproperty) /* mpropdefs on <var_mproperty:MMethod>*/;
2183 var13 = ((val* (*)(val*))(var12->class->vft[COLOR_abstract_collection__Collection__iterator]))(var12) /* iterator on <var12:Array[MPropDef](Array[MMethodDef])>*/;
2184 for(;;) {
2185 var14 = ((short int (*)(val*))(var13->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var13) /* is_ok on <var13:Iterator[nullable Object]>*/;
2186 if(!var14) break;
2187 var15 = ((val* (*)(val*))(var13->class->vft[COLOR_abstract_collection__Iterator__item]))(var13) /* item on <var13:Iterator[nullable Object]>*/;
2188 var_d = var15;
2189 var16 = ((short int (*)(val*))(var_d->class->vft[COLOR_model__MMethodDef__is_abstract]))(var_d) /* is_abstract on <var_d:MMethodDef>*/;
2190 if (var16){
2191 goto CONTINUE_label;
2192 } else {
2193 }
2194 var17 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_methoddefs]))(self) /* live_methoddefs on <self:RapidTypeAnalysis>*/;
2195 var18 = ((short int (*)(val*, val*))(var17->class->vft[COLOR_abstract_collection__Collection__has]))(var17, var_d) /* has on <var17:HashSet[MMethodDef]>*/;
2196 var19 = !var18;
2197 if (var19){
2198 goto RET_LABEL;
2199 } else {
2200 }
2201 CONTINUE_label: (void)0;
2202 ((void (*)(val*))(var13->class->vft[COLOR_abstract_collection__Iterator__next]))(var13) /* next on <var13:Iterator[nullable Object]>*/;
2203 }
2204 BREAK_label: (void)0;
2205 var20 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__totry_methods]))(self) /* totry_methods on <self:RapidTypeAnalysis>*/;
2206 var21 = ((val* (*)(val*))(var_mpropdef->class->vft[COLOR_model__MPropDef__mproperty]))(var_mpropdef) /* mproperty on <var_mpropdef:MMethodDef>*/;
2207 ((void (*)(val*, val*))(var20->class->vft[COLOR_abstract_collection__RemovableCollection__remove]))(var20, var21) /* remove on <var20:HashSet[MMethod]>*/;
2208 RET_LABEL:;
2209 }
2210 /* method rapid_type_analysis#RapidTypeAnalysis#add_call for (self: Object, MMethodDef) */
2211 void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__add_call(val* self, val* p0) {
2212 rapid_type_analysis__RapidTypeAnalysis__add_call(self, p0);
2213 RET_LABEL:;
2214 }
2215 /* method rapid_type_analysis#RapidTypeAnalysis#add_send for (self: RapidTypeAnalysis, MType, MMethod) */
2216 void rapid_type_analysis__RapidTypeAnalysis__add_send(val* self, val* p0, val* p1) {
2217 val* var_recv /* var recv: MType */;
2218 val* var_mproperty /* var mproperty: MMethod */;
2219 val* var /* : HashSet[MMethod] */;
2220 short int var1 /* : Bool */;
2221 val* var2 /* : HashSet[MMethod] */;
2222 val* var3 /* : Array[MPropDef] */;
2223 long var4 /* : Int */;
2224 long var5 /* : Int */;
2225 short int var6 /* : Bool */;
2226 short int var8 /* : Bool */;
2227 val* var9 /* : Array[MPropDef] */;
2228 val* var10 /* : nullable Object */;
2229 val* var_d /* var d: MMethodDef */;
2230 val* var11 /* : HashSet[MMethod] */;
2231 val* var12 /* : HashSet[MClass] */;
2232 val* var13 /* : Iterator[nullable Object] */;
2233 short int var14 /* : Bool */;
2234 val* var15 /* : nullable Object */;
2235 val* var_c /* var c: MClass */;
2236 val* var16 /* : MClassDef */;
2237 val* var17 /* : MClassType */;
2238 var_recv = p0;
2239 var_mproperty = p1;
2240 var = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_methods]))(self) /* live_methods on <self:RapidTypeAnalysis>*/;
2241 var1 = ((short int (*)(val*, val*))(var->class->vft[COLOR_abstract_collection__Collection__has]))(var, var_mproperty) /* has on <var:HashSet[MMethod]>*/;
2242 if (var1){
2243 goto RET_LABEL;
2244 } else {
2245 }
2246 var2 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_methods]))(self) /* live_methods on <self:RapidTypeAnalysis>*/;
2247 ((void (*)(val*, val*))(var2->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var2, var_mproperty) /* add on <var2:HashSet[MMethod]>*/;
2248 var3 = ((val* (*)(val*))(var_mproperty->class->vft[COLOR_model__MProperty__mpropdefs]))(var_mproperty) /* mpropdefs on <var_mproperty:MMethod>*/;
2249 var4 = ((long (*)(val*))(var3->class->vft[COLOR_abstract_collection__Collection__length]))(var3) /* length on <var3:Array[MPropDef](Array[MMethodDef])>*/;
2250 var5 = 1;
2251 { /* Inline kernel#Int#== (var4,var5) */
2252 var8 = var4 == var5;
2253 var6 = var8;
2254 goto RET_LABEL7;
2255 RET_LABEL7:(void)0;
2256 }
2257 if (var6){
2258 var9 = ((val* (*)(val*))(var_mproperty->class->vft[COLOR_model__MProperty__mpropdefs]))(var_mproperty) /* mpropdefs on <var_mproperty:MMethod>*/;
2259 var10 = ((val* (*)(val*))(var9->class->vft[COLOR_abstract_collection__Collection__first]))(var9) /* first on <var9:Array[MPropDef](Array[MMethodDef])>*/;
2260 var_d = var10;
2261 ((void (*)(val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__add_call]))(self, var_d) /* add_call on <self:RapidTypeAnalysis>*/;
2262 goto RET_LABEL;
2263 } else {
2264 }
2265 var11 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__totry_methods]))(self) /* totry_methods on <self:RapidTypeAnalysis>*/;
2266 ((void (*)(val*, val*))(var11->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var11, var_mproperty) /* add on <var11:HashSet[MMethod]>*/;
2267 var12 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_classes]))(self) /* live_classes on <self:RapidTypeAnalysis>*/;
2268 var13 = ((val* (*)(val*))(var12->class->vft[COLOR_abstract_collection__Collection__iterator]))(var12) /* iterator on <var12:HashSet[MClass]>*/;
2269 for(;;) {
2270 var14 = ((short int (*)(val*))(var13->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var13) /* is_ok on <var13:Iterator[nullable Object]>*/;
2271 if(!var14) break;
2272 var15 = ((val* (*)(val*))(var13->class->vft[COLOR_abstract_collection__Iterator__item]))(var13) /* item on <var13:Iterator[nullable Object]>*/;
2273 var_c = var15;
2274 var16 = ((val* (*)(val*))(var_c->class->vft[COLOR_model__MClass__intro]))(var_c) /* intro on <var_c:MClass>*/;
2275 var17 = ((val* (*)(val*))(var16->class->vft[COLOR_model__MClassDef__bound_mtype]))(var16) /* bound_mtype on <var16:MClassDef>*/;
2276 ((void (*)(val*, val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__try_send]))(self, var17, var_mproperty) /* try_send on <self:RapidTypeAnalysis>*/;
2277 CONTINUE_label: (void)0;
2278 ((void (*)(val*))(var13->class->vft[COLOR_abstract_collection__Iterator__next]))(var13) /* next on <var13:Iterator[nullable Object]>*/;
2279 }
2280 BREAK_label: (void)0;
2281 RET_LABEL:;
2282 }
2283 /* method rapid_type_analysis#RapidTypeAnalysis#add_send for (self: Object, MType, MMethod) */
2284 void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__add_send(val* self, val* p0, val* p1) {
2285 rapid_type_analysis__RapidTypeAnalysis__add_send(self, p0, p1);
2286 RET_LABEL:;
2287 }
2288 /* method rapid_type_analysis#RapidTypeAnalysis#try_super_send for (self: RapidTypeAnalysis, MClassType, MMethodDef) */
2289 void rapid_type_analysis__RapidTypeAnalysis__try_super_send(val* self, val* p0, val* p1) {
2290 val* var_recv /* var recv: MClassType */;
2291 val* var_mpropdef /* var mpropdef: MMethodDef */;
2292 val* var /* : MClass */;
2293 val* var1 /* : MClassDef */;
2294 val* var2 /* : MClassType */;
2295 val* var3 /* : MModule */;
2296 val* var4 /* : Set[MClassDef] */;
2297 val* var5 /* : MClassDef */;
2298 short int var6 /* : Bool */;
2299 short int var7 /* : Bool */;
2300 val* var8 /* : MModule */;
2301 val* var9 /* : MPropDef */;
2302 val* var_d /* var d: MMethodDef */;
2303 var_recv = p0;
2304 var_mpropdef = p1;
2305 var = ((val* (*)(val*))(var_recv->class->vft[COLOR_model__MClassType__mclass]))(var_recv) /* mclass on <var_recv:MClassType>*/;
2306 var1 = ((val* (*)(val*))(var->class->vft[COLOR_model__MClass__intro]))(var) /* intro on <var:MClass>*/;
2307 var2 = ((val* (*)(val*))(var1->class->vft[COLOR_model__MClassDef__bound_mtype]))(var1) /* bound_mtype on <var1:MClassDef>*/;
2308 var_recv = var2;
2309 var3 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on <self:RapidTypeAnalysis>*/;
2310 var4 = ((val* (*)(val*, val*))(var_recv->class->vft[COLOR_model__MType__collect_mclassdefs]))(var_recv, var3) /* collect_mclassdefs on <var_recv:MClassType>*/;
2311 var5 = ((val* (*)(val*))(var_mpropdef->class->vft[COLOR_model__MPropDef__mclassdef]))(var_mpropdef) /* mclassdef on <var_mpropdef:MMethodDef>*/;
2312 var6 = ((short int (*)(val*, val*))(var4->class->vft[COLOR_abstract_collection__Collection__has]))(var4, var5) /* has on <var4:Set[MClassDef]>*/;
2313 var7 = !var6;
2314 if (var7){
2315 goto RET_LABEL;
2316 } else {
2317 }
2318 var8 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(self) /* mainmodule on <self:RapidTypeAnalysis>*/;
2319 var9 = ((val* (*)(val*, val*, val*))(var_mpropdef->class->vft[COLOR_model__MPropDef__lookup_next_definition]))(var_mpropdef, var8, var_recv) /* lookup_next_definition on <var_mpropdef:MMethodDef>*/;
2320 var_d = var9;
2321 ((void (*)(val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__add_call]))(self, var_d) /* add_call on <self:RapidTypeAnalysis>*/;
2322 RET_LABEL:;
2323 }
2324 /* method rapid_type_analysis#RapidTypeAnalysis#try_super_send for (self: Object, MClassType, MMethodDef) */
2325 void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__try_super_send(val* self, val* p0, val* p1) {
2326 rapid_type_analysis__RapidTypeAnalysis__try_super_send(self, p0, p1);
2327 RET_LABEL:;
2328 }
2329 /* method rapid_type_analysis#RapidTypeAnalysis#add_super_send for (self: RapidTypeAnalysis, MType, MMethodDef) */
2330 void rapid_type_analysis__RapidTypeAnalysis__add_super_send(val* self, val* p0, val* p1) {
2331 val* var_recv /* var recv: MType */;
2332 val* var_mpropdef /* var mpropdef: MMethodDef */;
2333 val* var /* : HashSet[MMethodDef] */;
2334 short int var1 /* : Bool */;
2335 val* var2 /* : HashSet[MMethodDef] */;
2336 val* var3 /* : HashSet[MClassType] */;
2337 val* var4 /* : Iterator[nullable Object] */;
2338 short int var5 /* : Bool */;
2339 val* var6 /* : nullable Object */;
2340 val* var_t /* var t: MClassType */;
2341 var_recv = p0;
2342 var_mpropdef = p1;
2343 var = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_super_sends]))(self) /* live_super_sends on <self:RapidTypeAnalysis>*/;
2344 var1 = ((short int (*)(val*, val*))(var->class->vft[COLOR_abstract_collection__Collection__has]))(var, var_mpropdef) /* has on <var:HashSet[MMethodDef]>*/;
2345 if (var1){
2346 goto RET_LABEL;
2347 } else {
2348 }
2349 var2 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_super_sends]))(self) /* live_super_sends on <self:RapidTypeAnalysis>*/;
2350 ((void (*)(val*, val*))(var2->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var2, var_mpropdef) /* add on <var2:HashSet[MMethodDef]>*/;
2351 var3 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__live_types]))(self) /* live_types on <self:RapidTypeAnalysis>*/;
2352 var4 = ((val* (*)(val*))(var3->class->vft[COLOR_abstract_collection__Collection__iterator]))(var3) /* iterator on <var3:HashSet[MClassType]>*/;
2353 for(;;) {
2354 var5 = ((short int (*)(val*))(var4->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var4) /* is_ok on <var4:Iterator[nullable Object]>*/;
2355 if(!var5) break;
2356 var6 = ((val* (*)(val*))(var4->class->vft[COLOR_abstract_collection__Iterator__item]))(var4) /* item on <var4:Iterator[nullable Object]>*/;
2357 var_t = var6;
2358 ((void (*)(val*, val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__try_super_send]))(self, var_t, var_mpropdef) /* try_super_send on <self:RapidTypeAnalysis>*/;
2359 CONTINUE_label: (void)0;
2360 ((void (*)(val*))(var4->class->vft[COLOR_abstract_collection__Iterator__next]))(var4) /* next on <var4:Iterator[nullable Object]>*/;
2361 }
2362 BREAK_label: (void)0;
2363 RET_LABEL:;
2364 }
2365 /* method rapid_type_analysis#RapidTypeAnalysis#add_super_send for (self: Object, MType, MMethodDef) */
2366 void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__add_super_send(val* self, val* p0, val* p1) {
2367 rapid_type_analysis__RapidTypeAnalysis__add_super_send(self, p0, p1);
2368 RET_LABEL:;
2369 }
2370 /* method rapid_type_analysis#RapidTypeAnalysis#init for (self: RapidTypeAnalysis, ModelBuilder, MModule) */
2371 void rapid_type_analysis__RapidTypeAnalysis__init(val* self, val* p0, val* p1) {
2372 self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dmodelbuilder].val = p0; /* @modelbuilder on <self:RapidTypeAnalysis> */
2373 self->attrs[COLOR_rapid_type_analysis__RapidTypeAnalysis___64dmainmodule].val = p1; /* @mainmodule on <self:RapidTypeAnalysis> */
2374 RET_LABEL:;
2375 }
2376 /* method rapid_type_analysis#RapidTypeAnalysis#init for (self: Object, ModelBuilder, MModule) */
2377 void VIRTUAL_rapid_type_analysis__RapidTypeAnalysis__init(val* self, val* p0, val* p1) {
2378 rapid_type_analysis__RapidTypeAnalysis__init(self, p0, p1);
2379 RET_LABEL:;
2380 }
2381 /* method rapid_type_analysis#RapidTypeVisitor#analysis for (self: RapidTypeVisitor): RapidTypeAnalysis */
2382 val* rapid_type_analysis__RapidTypeVisitor__analysis(val* self) {
2383 val* var /* : RapidTypeAnalysis */;
2384 val* var1 /* : RapidTypeAnalysis */;
2385 var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeVisitor___64danalysis].val; /* @analysis on <self:RapidTypeVisitor> */
2386 if (var1 == NULL) {
2387 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @analysis");
2388 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 389);
2389 show_backtrace(1);
2390 }
2391 var = var1;
2392 RET_LABEL:;
2393 return var;
2394 }
2395 /* method rapid_type_analysis#RapidTypeVisitor#analysis for (self: Object): RapidTypeAnalysis */
2396 val* VIRTUAL_rapid_type_analysis__RapidTypeVisitor__analysis(val* self) {
2397 val* var /* : RapidTypeAnalysis */;
2398 val* var1 /* : RapidTypeAnalysis */;
2399 var1 = rapid_type_analysis__RapidTypeVisitor__analysis(self);
2400 var = var1;
2401 RET_LABEL:;
2402 return var;
2403 }
2404 /* method rapid_type_analysis#RapidTypeVisitor#analysis= for (self: RapidTypeVisitor, RapidTypeAnalysis) */
2405 void rapid_type_analysis__RapidTypeVisitor__analysis_61d(val* self, val* p0) {
2406 self->attrs[COLOR_rapid_type_analysis__RapidTypeVisitor___64danalysis].val = p0; /* @analysis on <self:RapidTypeVisitor> */
2407 RET_LABEL:;
2408 }
2409 /* method rapid_type_analysis#RapidTypeVisitor#analysis= for (self: Object, RapidTypeAnalysis) */
2410 void VIRTUAL_rapid_type_analysis__RapidTypeVisitor__analysis_61d(val* self, val* p0) {
2411 rapid_type_analysis__RapidTypeVisitor__analysis_61d(self, p0);
2412 RET_LABEL:;
2413 }
2414 /* method rapid_type_analysis#RapidTypeVisitor#receiver for (self: RapidTypeVisitor): MClassType */
2415 val* rapid_type_analysis__RapidTypeVisitor__receiver(val* self) {
2416 val* var /* : MClassType */;
2417 val* var1 /* : MClassType */;
2418 var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeVisitor___64dreceiver].val; /* @receiver on <self:RapidTypeVisitor> */
2419 if (var1 == NULL) {
2420 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @receiver");
2421 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 390);
2422 show_backtrace(1);
2423 }
2424 var = var1;
2425 RET_LABEL:;
2426 return var;
2427 }
2428 /* method rapid_type_analysis#RapidTypeVisitor#receiver for (self: Object): MClassType */
2429 val* VIRTUAL_rapid_type_analysis__RapidTypeVisitor__receiver(val* self) {
2430 val* var /* : MClassType */;
2431 val* var1 /* : MClassType */;
2432 var1 = rapid_type_analysis__RapidTypeVisitor__receiver(self);
2433 var = var1;
2434 RET_LABEL:;
2435 return var;
2436 }
2437 /* method rapid_type_analysis#RapidTypeVisitor#receiver= for (self: RapidTypeVisitor, MClassType) */
2438 void rapid_type_analysis__RapidTypeVisitor__receiver_61d(val* self, val* p0) {
2439 self->attrs[COLOR_rapid_type_analysis__RapidTypeVisitor___64dreceiver].val = p0; /* @receiver on <self:RapidTypeVisitor> */
2440 RET_LABEL:;
2441 }
2442 /* method rapid_type_analysis#RapidTypeVisitor#receiver= for (self: Object, MClassType) */
2443 void VIRTUAL_rapid_type_analysis__RapidTypeVisitor__receiver_61d(val* self, val* p0) {
2444 rapid_type_analysis__RapidTypeVisitor__receiver_61d(self, p0);
2445 RET_LABEL:;
2446 }
2447 /* method rapid_type_analysis#RapidTypeVisitor#mpropdef for (self: RapidTypeVisitor): MPropDef */
2448 val* rapid_type_analysis__RapidTypeVisitor__mpropdef(val* self) {
2449 val* var /* : MPropDef */;
2450 val* var1 /* : MPropDef */;
2451 var1 = self->attrs[COLOR_rapid_type_analysis__RapidTypeVisitor___64dmpropdef].val; /* @mpropdef on <self:RapidTypeVisitor> */
2452 if (var1 == NULL) {
2453 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @mpropdef");
2454 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 391);
2455 show_backtrace(1);
2456 }
2457 var = var1;
2458 RET_LABEL:;
2459 return var;
2460 }
2461 /* method rapid_type_analysis#RapidTypeVisitor#mpropdef for (self: Object): MPropDef */
2462 val* VIRTUAL_rapid_type_analysis__RapidTypeVisitor__mpropdef(val* self) {
2463 val* var /* : MPropDef */;
2464 val* var1 /* : MPropDef */;
2465 var1 = rapid_type_analysis__RapidTypeVisitor__mpropdef(self);
2466 var = var1;
2467 RET_LABEL:;
2468 return var;
2469 }
2470 /* method rapid_type_analysis#RapidTypeVisitor#mpropdef= for (self: RapidTypeVisitor, MPropDef) */
2471 void rapid_type_analysis__RapidTypeVisitor__mpropdef_61d(val* self, val* p0) {
2472 self->attrs[COLOR_rapid_type_analysis__RapidTypeVisitor___64dmpropdef].val = p0; /* @mpropdef on <self:RapidTypeVisitor> */
2473 RET_LABEL:;
2474 }
2475 /* method rapid_type_analysis#RapidTypeVisitor#mpropdef= for (self: Object, MPropDef) */
2476 void VIRTUAL_rapid_type_analysis__RapidTypeVisitor__mpropdef_61d(val* self, val* p0) {
2477 rapid_type_analysis__RapidTypeVisitor__mpropdef_61d(self, p0);
2478 RET_LABEL:;
2479 }
2480 /* method rapid_type_analysis#RapidTypeVisitor#init for (self: RapidTypeVisitor, RapidTypeAnalysis, MClassType, MPropDef) */
2481 void rapid_type_analysis__RapidTypeVisitor__init(val* self, val* p0, val* p1, val* p2) {
2482 val* var_analysis /* var analysis: RapidTypeAnalysis */;
2483 val* var_receiver /* var receiver: MClassType */;
2484 val* var_mpropdef /* var mpropdef: MPropDef */;
2485 short int var /* : Bool */;
2486 short int var1 /* : Bool */;
2487 var_analysis = p0;
2488 var_receiver = p1;
2489 var_mpropdef = p2;
2490 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__Visitor__init]))(self) /* init on <self:RapidTypeVisitor>*/;
2491 ((void (*)(val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__analysis_61d]))(self, var_analysis) /* analysis= on <self:RapidTypeVisitor>*/;
2492 ((void (*)(val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__receiver_61d]))(self, var_receiver) /* receiver= on <self:RapidTypeVisitor>*/;
2493 ((void (*)(val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__mpropdef_61d]))(self, var_mpropdef) /* mpropdef= on <self:RapidTypeVisitor>*/;
2494 var = ((short int (*)(val*))(var_receiver->class->vft[COLOR_model__MType__need_anchor]))(var_receiver) /* need_anchor on <var_receiver:MClassType>*/;
2495 var1 = !var;
2496 if (!var1) {
2497 fprintf(stderr, "Runtime error: %s", "Assert failed");
2498 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 398);
2499 show_backtrace(1);
2500 }
2501 RET_LABEL:;
2502 }
2503 /* method rapid_type_analysis#RapidTypeVisitor#init for (self: Object, RapidTypeAnalysis, MClassType, MPropDef) */
2504 void VIRTUAL_rapid_type_analysis__RapidTypeVisitor__init(val* self, val* p0, val* p1, val* p2) {
2505 rapid_type_analysis__RapidTypeVisitor__init(self, p0, p1, p2);
2506 RET_LABEL:;
2507 }
2508 /* method rapid_type_analysis#RapidTypeVisitor#visit for (self: RapidTypeVisitor, ANode) */
2509 void rapid_type_analysis__RapidTypeVisitor__visit(val* self, val* p0) {
2510 val* var_n /* var n: ANode */;
2511 short int var /* : Bool */;
2512 int cltype;
2513 int idtype;
2514 val* var1 /* : nullable MType */;
2515 val* var_implicit_cast_to /* var implicit_cast_to: nullable MType */;
2516 val* var2 /* : null */;
2517 short int var3 /* : Bool */;
2518 short int var4 /* : Bool */;
2519 int cltype5;
2520 int idtype6;
2521 short int var7 /* : Bool */;
2522 var_n = p0;
2523 ((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>*/;
2524 /* <var_n:ANode> isa AExpr */
2525 cltype = type_parser_nodes__AExpr.color;
2526 idtype = type_parser_nodes__AExpr.id;
2527 if(cltype >= var_n->type->table_size) {
2528 var = 0;
2529 } else {
2530 var = var_n->type->type_table[cltype] == idtype;
2531 }
2532 if (var){
2533 var1 = ((val* (*)(val*))(var_n->class->vft[COLOR_typing__AExpr__implicit_cast_to]))(var_n) /* implicit_cast_to on <var_n:ANode(AExpr)>*/;
2534 var_implicit_cast_to = var1;
2535 var2 = NULL;
2536 if (var_implicit_cast_to == NULL) {
2537 var3 = 0; /* is null */
2538 } else {
2539 var3 = 1; /* arg is null and recv is not */
2540 }
2541 if (var3){
2542 ((void (*)(val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_cast_type]))(self, var_implicit_cast_to) /* add_cast_type on <self:RapidTypeVisitor>*/;
2543 } else {
2544 }
2545 } else {
2546 }
2547 /* <var_n:ANode> isa AAnnotations */
2548 cltype5 = type_parser_nodes__AAnnotations.color;
2549 idtype6 = type_parser_nodes__AAnnotations.id;
2550 if(cltype5 >= var_n->type->table_size) {
2551 var4 = 0;
2552 } else {
2553 var4 = var_n->type->type_table[cltype5] == idtype6;
2554 }
2555 var7 = !var4;
2556 if (var7){
2557 ((void (*)(val*, val*))(var_n->class->vft[COLOR_parser_nodes__ANode__visit_all]))(var_n, self) /* visit_all on <var_n:ANode>*/;
2558 } else {
2559 }
2560 RET_LABEL:;
2561 }
2562 /* method rapid_type_analysis#RapidTypeVisitor#visit for (self: Object, ANode) */
2563 void VIRTUAL_rapid_type_analysis__RapidTypeVisitor__visit(val* self, val* p0) {
2564 rapid_type_analysis__RapidTypeVisitor__visit(self, p0);
2565 RET_LABEL:;
2566 }
2567 /* method rapid_type_analysis#RapidTypeVisitor#cleanup_type for (self: RapidTypeVisitor, MType): nullable MClassType */
2568 val* rapid_type_analysis__RapidTypeVisitor__cleanup_type(val* self, val* p0) {
2569 val* var /* : nullable MClassType */;
2570 val* var_mtype /* var mtype: MType */;
2571 val* var1 /* : RapidTypeAnalysis */;
2572 val* var2 /* : MModule */;
2573 val* var3 /* : MClassType */;
2574 val* var4 /* : MType */;
2575 short int var5 /* : Bool */;
2576 int cltype;
2577 int idtype;
2578 val* var6 /* : null */;
2579 short int var7 /* : Bool */;
2580 int cltype8;
2581 int idtype9;
2582 val* var10 /* : MType */;
2583 short int var11 /* : Bool */;
2584 int cltype12;
2585 int idtype13;
2586 short int var14 /* : Bool */;
2587 short int var15 /* : Bool */;
2588 var_mtype = p0;
2589 var1 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__analysis]))(self) /* analysis on <self:RapidTypeVisitor>*/;
2590 var2 = ((val* (*)(val*))(var1->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(var1) /* mainmodule on <var1:RapidTypeAnalysis>*/;
2591 var3 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__receiver]))(self) /* receiver on <self:RapidTypeVisitor>*/;
2592 var4 = ((val* (*)(val*, val*, val*))(var_mtype->class->vft[COLOR_model__MType__anchor_to]))(var_mtype, var2, var3) /* anchor_to on <var_mtype:MType>*/;
2593 var_mtype = var4;
2594 /* <var_mtype:MType> isa MNullType */
2595 cltype = type_model__MNullType.color;
2596 idtype = type_model__MNullType.id;
2597 if(cltype >= var_mtype->type->table_size) {
2598 var5 = 0;
2599 } else {
2600 var5 = var_mtype->type->type_table[cltype] == idtype;
2601 }
2602 if (var5){
2603 var6 = NULL;
2604 var = var6;
2605 goto RET_LABEL;
2606 } else {
2607 }
2608 /* <var_mtype:MType> isa MNullableType */
2609 cltype8 = type_model__MNullableType.color;
2610 idtype9 = type_model__MNullableType.id;
2611 if(cltype8 >= var_mtype->type->table_size) {
2612 var7 = 0;
2613 } else {
2614 var7 = var_mtype->type->type_table[cltype8] == idtype9;
2615 }
2616 if (var7){
2617 var10 = ((val* (*)(val*))(var_mtype->class->vft[COLOR_model__MNullableType__mtype]))(var_mtype) /* mtype on <var_mtype:MType(MNullableType)>*/;
2618 var_mtype = var10;
2619 } else {
2620 }
2621 /* <var_mtype:MType> isa MClassType */
2622 cltype12 = type_model__MClassType.color;
2623 idtype13 = type_model__MClassType.id;
2624 if(cltype12 >= var_mtype->type->table_size) {
2625 var11 = 0;
2626 } else {
2627 var11 = var_mtype->type->type_table[cltype12] == idtype13;
2628 }
2629 if (!var11) {
2630 fprintf(stderr, "Runtime error: %s", "Assert failed");
2631 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 420);
2632 show_backtrace(1);
2633 }
2634 var14 = ((short int (*)(val*))(var_mtype->class->vft[COLOR_model__MType__need_anchor]))(var_mtype) /* need_anchor on <var_mtype:MType(MClassType)>*/;
2635 var15 = !var14;
2636 if (!var15) {
2637 fprintf(stderr, "Runtime error: %s", "Assert failed");
2638 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 421);
2639 show_backtrace(1);
2640 }
2641 var = var_mtype;
2642 goto RET_LABEL;
2643 RET_LABEL:;
2644 return var;
2645 }
2646 /* method rapid_type_analysis#RapidTypeVisitor#cleanup_type for (self: Object, MType): nullable MClassType */
2647 val* VIRTUAL_rapid_type_analysis__RapidTypeVisitor__cleanup_type(val* self, val* p0) {
2648 val* var /* : nullable MClassType */;
2649 val* var1 /* : nullable MClassType */;
2650 var1 = rapid_type_analysis__RapidTypeVisitor__cleanup_type(self, p0);
2651 var = var1;
2652 RET_LABEL:;
2653 return var;
2654 }
2655 /* method rapid_type_analysis#RapidTypeVisitor#get_class for (self: RapidTypeVisitor, String): MClass */
2656 val* rapid_type_analysis__RapidTypeVisitor__get_class(val* self, val* p0) {
2657 val* var /* : MClass */;
2658 val* var_name /* var name: String */;
2659 val* var1 /* : RapidTypeAnalysis */;
2660 val* var2 /* : MModule */;
2661 val* var3 /* : MClass */;
2662 var_name = p0;
2663 var1 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__analysis]))(self) /* analysis on <self:RapidTypeVisitor>*/;
2664 var2 = ((val* (*)(val*))(var1->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(var1) /* mainmodule on <var1:RapidTypeAnalysis>*/;
2665 var3 = ((val* (*)(val*, val*))(var2->class->vft[COLOR_model__MModule__get_primitive_class]))(var2, var_name) /* get_primitive_class on <var2:MModule>*/;
2666 var = var3;
2667 goto RET_LABEL;
2668 RET_LABEL:;
2669 return var;
2670 }
2671 /* method rapid_type_analysis#RapidTypeVisitor#get_class for (self: Object, String): MClass */
2672 val* VIRTUAL_rapid_type_analysis__RapidTypeVisitor__get_class(val* self, val* p0) {
2673 val* var /* : MClass */;
2674 val* var1 /* : MClass */;
2675 var1 = rapid_type_analysis__RapidTypeVisitor__get_class(self, p0);
2676 var = var1;
2677 RET_LABEL:;
2678 return var;
2679 }
2680 /* method rapid_type_analysis#RapidTypeVisitor#get_method for (self: RapidTypeVisitor, MType, String): MMethod */
2681 val* rapid_type_analysis__RapidTypeVisitor__get_method(val* self, val* p0, val* p1) {
2682 val* var /* : MMethod */;
2683 val* var_recv /* var recv: MType */;
2684 val* var_name /* var name: String */;
2685 val* var1 /* : nullable MClassType */;
2686 val* var_mtype /* var mtype: nullable MClassType */;
2687 val* var2 /* : null */;
2688 short int var3 /* : Bool */;
2689 val* var4 /* : RapidTypeAnalysis */;
2690 val* var5 /* : ModelBuilder */;
2691 val* var6 /* : nullable ANode */;
2692 val* var7 /* : MClass */;
2693 val* var8 /* : RapidTypeAnalysis */;
2694 val* var9 /* : MModule */;
2695 val* var10 /* : MMethod */;
2696 var_recv = p0;
2697 var_name = p1;
2698 var1 = ((val* (*)(val*, val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__cleanup_type]))(self, var_recv) /* cleanup_type on <self:RapidTypeVisitor>*/;
2699 var_mtype = var1;
2700 var2 = NULL;
2701 if (var_mtype == NULL) {
2702 var3 = 0; /* is null */
2703 } else {
2704 var3 = 1; /* arg is null and recv is not */
2705 }
2706 if (!var3) {
2707 fprintf(stderr, "Runtime error: %s", "Assert failed");
2708 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 433);
2709 show_backtrace(1);
2710 }
2711 var4 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__analysis]))(self) /* analysis on <self:RapidTypeVisitor>*/;
2712 var5 = ((val* (*)(val*))(var4->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__modelbuilder]))(var4) /* modelbuilder on <var4:RapidTypeAnalysis>*/;
2713 var6 = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__Visitor__current_node]))(self) /* current_node on <self:RapidTypeVisitor>*/;
2714 if (var6 == NULL) {
2715 fprintf(stderr, "Runtime error: %s", "Cast failed");
2716 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 434);
2717 show_backtrace(1);
2718 }
2719 var7 = ((val* (*)(val*))(var_mtype->class->vft[COLOR_model__MClassType__mclass]))(var_mtype) /* mclass on <var_mtype:nullable MClassType(MClassType)>*/;
2720 var8 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__analysis]))(self) /* analysis on <self:RapidTypeVisitor>*/;
2721 var9 = ((val* (*)(val*))(var8->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(var8) /* mainmodule on <var8:RapidTypeAnalysis>*/;
2722 var10 = ((val* (*)(val*, val*, val*, val*, val*))(var5->class->vft[COLOR_modelbuilder__ModelBuilder__force_get_primitive_method]))(var5, var6, var_name, var7, var9) /* force_get_primitive_method on <var5:ModelBuilder>*/;
2723 var = var10;
2724 goto RET_LABEL;
2725 RET_LABEL:;
2726 return var;
2727 }
2728 /* method rapid_type_analysis#RapidTypeVisitor#get_method for (self: Object, MType, String): MMethod */
2729 val* VIRTUAL_rapid_type_analysis__RapidTypeVisitor__get_method(val* self, val* p0, val* p1) {
2730 val* var /* : MMethod */;
2731 val* var1 /* : MMethod */;
2732 var1 = rapid_type_analysis__RapidTypeVisitor__get_method(self, p0, p1);
2733 var = var1;
2734 RET_LABEL:;
2735 return var;
2736 }
2737 /* method rapid_type_analysis#RapidTypeVisitor#add_type for (self: RapidTypeVisitor, MClassType) */
2738 void rapid_type_analysis__RapidTypeVisitor__add_type(val* self, val* p0) {
2739 val* var_mtype /* var mtype: MClassType */;
2740 val* var /* : RapidTypeAnalysis */;
2741 val* var1 /* : MClassType */;
2742 var_mtype = p0;
2743 var = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__analysis]))(self) /* analysis on <self:RapidTypeVisitor>*/;
2744 var1 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__receiver]))(self) /* receiver on <self:RapidTypeVisitor>*/;
2745 ((void (*)(val*, val*, val*))(var->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__add_new]))(var, var1, var_mtype) /* add_new on <var:RapidTypeAnalysis>*/;
2746 RET_LABEL:;
2747 }
2748 /* method rapid_type_analysis#RapidTypeVisitor#add_type for (self: Object, MClassType) */
2749 void VIRTUAL_rapid_type_analysis__RapidTypeVisitor__add_type(val* self, val* p0) {
2750 rapid_type_analysis__RapidTypeVisitor__add_type(self, p0);
2751 RET_LABEL:;
2752 }
2753 /* method rapid_type_analysis#RapidTypeVisitor#add_monomorphic_send for (self: RapidTypeVisitor, MType, MMethod) */
2754 void rapid_type_analysis__RapidTypeVisitor__add_monomorphic_send(val* self, val* p0, val* p1) {
2755 val* var_mtype /* var mtype: MType */;
2756 val* var_mproperty /* var mproperty: MMethod */;
2757 val* var /* : RapidTypeAnalysis */;
2758 short int var1 /* : Bool */;
2759 int cltype;
2760 int idtype;
2761 const char* var_class_name;
2762 var_mtype = p0;
2763 var_mproperty = p1;
2764 var = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__analysis]))(self) /* analysis on <self:RapidTypeVisitor>*/;
2765 /* <var_mtype:MType> isa MClassType */
2766 cltype = type_model__MClassType.color;
2767 idtype = type_model__MClassType.id;
2768 if(cltype >= var_mtype->type->table_size) {
2769 var1 = 0;
2770 } else {
2771 var1 = var_mtype->type->type_table[cltype] == idtype;
2772 }
2773 if (!var1) {
2774 var_class_name = var_mtype == NULL ? "null" : var_mtype->type->name;
2775 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
2776 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 439);
2777 show_backtrace(1);
2778 }
2779 ((void (*)(val*, val*, val*))(var->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__try_send]))(var, var_mtype, var_mproperty) /* try_send on <var:RapidTypeAnalysis>*/;
2780 RET_LABEL:;
2781 }
2782 /* method rapid_type_analysis#RapidTypeVisitor#add_monomorphic_send for (self: Object, MType, MMethod) */
2783 void VIRTUAL_rapid_type_analysis__RapidTypeVisitor__add_monomorphic_send(val* self, val* p0, val* p1) {
2784 rapid_type_analysis__RapidTypeVisitor__add_monomorphic_send(self, p0, p1);
2785 RET_LABEL:;
2786 }
2787 /* method rapid_type_analysis#RapidTypeVisitor#add_send for (self: RapidTypeVisitor, MType, MMethod) */
2788 void rapid_type_analysis__RapidTypeVisitor__add_send(val* self, val* p0, val* p1) {
2789 val* var_mtype /* var mtype: MType */;
2790 val* var_mproperty /* var mproperty: MMethod */;
2791 val* var /* : RapidTypeAnalysis */;
2792 var_mtype = p0;
2793 var_mproperty = p1;
2794 var = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__analysis]))(self) /* analysis on <self:RapidTypeVisitor>*/;
2795 ((void (*)(val*, val*, val*))(var->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__add_send]))(var, var_mtype, var_mproperty) /* add_send on <var:RapidTypeAnalysis>*/;
2796 RET_LABEL:;
2797 }
2798 /* method rapid_type_analysis#RapidTypeVisitor#add_send for (self: Object, MType, MMethod) */
2799 void VIRTUAL_rapid_type_analysis__RapidTypeVisitor__add_send(val* self, val* p0, val* p1) {
2800 rapid_type_analysis__RapidTypeVisitor__add_send(self, p0, p1);
2801 RET_LABEL:;
2802 }
2803 /* method rapid_type_analysis#RapidTypeVisitor#add_cast_type for (self: RapidTypeVisitor, MType) */
2804 void rapid_type_analysis__RapidTypeVisitor__add_cast_type(val* self, val* p0) {
2805 val* var_mtype /* var mtype: MType */;
2806 val* var /* : RapidTypeAnalysis */;
2807 var_mtype = p0;
2808 var = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__analysis]))(self) /* analysis on <self:RapidTypeVisitor>*/;
2809 ((void (*)(val*, val*))(var->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__add_cast]))(var, var_mtype) /* add_cast on <var:RapidTypeAnalysis>*/;
2810 RET_LABEL:;
2811 }
2812 /* method rapid_type_analysis#RapidTypeVisitor#add_cast_type for (self: Object, MType) */
2813 void VIRTUAL_rapid_type_analysis__RapidTypeVisitor__add_cast_type(val* self, val* p0) {
2814 rapid_type_analysis__RapidTypeVisitor__add_cast_type(self, p0);
2815 RET_LABEL:;
2816 }
2817 /* method rapid_type_analysis#RapidTypeVisitor#add_callsite for (self: RapidTypeVisitor, nullable CallSite) */
2818 void rapid_type_analysis__RapidTypeVisitor__add_callsite(val* self, val* p0) {
2819 val* var_callsite /* var callsite: nullable CallSite */;
2820 val* var /* : null */;
2821 short int var1 /* : Bool */;
2822 val* var2 /* : RapidTypeAnalysis */;
2823 val* var3 /* : MType */;
2824 val* var4 /* : MMethod */;
2825 var_callsite = p0;
2826 var = NULL;
2827 if (var_callsite == NULL) {
2828 var1 = 0; /* is null */
2829 } else {
2830 var1 = 1; /* arg is null and recv is not */
2831 }
2832 if (var1){
2833 var2 = ((val* (*)(val*))(self->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__analysis]))(self) /* analysis on <self:RapidTypeVisitor>*/;
2834 var3 = ((val* (*)(val*))(var_callsite->class->vft[COLOR_typing__CallSite__recv]))(var_callsite) /* recv on <var_callsite:nullable CallSite(CallSite)>*/;
2835 var4 = ((val* (*)(val*))(var_callsite->class->vft[COLOR_typing__CallSite__mproperty]))(var_callsite) /* mproperty on <var_callsite:nullable CallSite(CallSite)>*/;
2836 ((void (*)(val*, val*, val*))(var2->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__add_send]))(var2, var3, var4) /* add_send on <var2:RapidTypeAnalysis>*/;
2837 } else {
2838 }
2839 RET_LABEL:;
2840 }
2841 /* method rapid_type_analysis#RapidTypeVisitor#add_callsite for (self: Object, nullable CallSite) */
2842 void VIRTUAL_rapid_type_analysis__RapidTypeVisitor__add_callsite(val* self, val* p0) {
2843 rapid_type_analysis__RapidTypeVisitor__add_callsite(self, p0);
2844 RET_LABEL:;
2845 }
2846 /* method rapid_type_analysis#ANode#accept_rapid_type_visitor for (self: ANode, RapidTypeVisitor) */
2847 void rapid_type_analysis__ANode__accept_rapid_type_visitor(val* self, val* p0) {
2848 val* var_v /* var v: RapidTypeVisitor */;
2849 var_v = p0;
2850 RET_LABEL:;
2851 }
2852 /* method rapid_type_analysis#ANode#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */
2853 void VIRTUAL_rapid_type_analysis__ANode__accept_rapid_type_visitor(val* self, val* p0) {
2854 rapid_type_analysis__ANode__accept_rapid_type_visitor(self, p0);
2855 RET_LABEL:;
2856 }
2857 /* method rapid_type_analysis#AIntExpr#accept_rapid_type_visitor for (self: AIntExpr, RapidTypeVisitor) */
2858 void rapid_type_analysis__AIntExpr__accept_rapid_type_visitor(val* self, val* p0) {
2859 val* var_v /* var v: RapidTypeVisitor */;
2860 val* var /* : nullable MType */;
2861 short int var1 /* : Bool */;
2862 int cltype;
2863 int idtype;
2864 const char* var_class_name;
2865 var_v = p0;
2866 var = ((val* (*)(val*))(self->class->vft[COLOR_typing__AExpr__mtype]))(self) /* mtype on <self:AIntExpr>*/;
2867 /* <var:nullable MType> isa MClassType */
2868 cltype = type_model__MClassType.color;
2869 idtype = type_model__MClassType.id;
2870 if(var == NULL) {
2871 var1 = 0;
2872 } else {
2873 if(cltype >= var->type->table_size) {
2874 var1 = 0;
2875 } else {
2876 var1 = var->type->type_table[cltype] == idtype;
2877 }
2878 }
2879 if (!var1) {
2880 var_class_name = var == NULL ? "null" : var->type->name;
2881 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
2882 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 459);
2883 show_backtrace(1);
2884 }
2885 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var) /* add_type on <var_v:RapidTypeVisitor>*/;
2886 RET_LABEL:;
2887 }
2888 /* method rapid_type_analysis#AIntExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */
2889 void VIRTUAL_rapid_type_analysis__AIntExpr__accept_rapid_type_visitor(val* self, val* p0) {
2890 rapid_type_analysis__AIntExpr__accept_rapid_type_visitor(self, p0);
2891 RET_LABEL:;
2892 }
2893 /* method rapid_type_analysis#AFloatExpr#accept_rapid_type_visitor for (self: AFloatExpr, RapidTypeVisitor) */
2894 void rapid_type_analysis__AFloatExpr__accept_rapid_type_visitor(val* self, val* p0) {
2895 val* var_v /* var v: RapidTypeVisitor */;
2896 val* var /* : nullable MType */;
2897 short int var1 /* : Bool */;
2898 int cltype;
2899 int idtype;
2900 const char* var_class_name;
2901 var_v = p0;
2902 var = ((val* (*)(val*))(self->class->vft[COLOR_typing__AExpr__mtype]))(self) /* mtype on <self:AFloatExpr>*/;
2903 /* <var:nullable MType> isa MClassType */
2904 cltype = type_model__MClassType.color;
2905 idtype = type_model__MClassType.id;
2906 if(var == NULL) {
2907 var1 = 0;
2908 } else {
2909 if(cltype >= var->type->table_size) {
2910 var1 = 0;
2911 } else {
2912 var1 = var->type->type_table[cltype] == idtype;
2913 }
2914 }
2915 if (!var1) {
2916 var_class_name = var == NULL ? "null" : var->type->name;
2917 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
2918 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 466);
2919 show_backtrace(1);
2920 }
2921 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var) /* add_type on <var_v:RapidTypeVisitor>*/;
2922 RET_LABEL:;
2923 }
2924 /* method rapid_type_analysis#AFloatExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */
2925 void VIRTUAL_rapid_type_analysis__AFloatExpr__accept_rapid_type_visitor(val* self, val* p0) {
2926 rapid_type_analysis__AFloatExpr__accept_rapid_type_visitor(self, p0);
2927 RET_LABEL:;
2928 }
2929 /* method rapid_type_analysis#ACharExpr#accept_rapid_type_visitor for (self: ACharExpr, RapidTypeVisitor) */
2930 void rapid_type_analysis__ACharExpr__accept_rapid_type_visitor(val* self, val* p0) {
2931 val* var_v /* var v: RapidTypeVisitor */;
2932 val* var /* : nullable MType */;
2933 short int var1 /* : Bool */;
2934 int cltype;
2935 int idtype;
2936 const char* var_class_name;
2937 var_v = p0;
2938 var = ((val* (*)(val*))(self->class->vft[COLOR_typing__AExpr__mtype]))(self) /* mtype on <self:ACharExpr>*/;
2939 /* <var:nullable MType> isa MClassType */
2940 cltype = type_model__MClassType.color;
2941 idtype = type_model__MClassType.id;
2942 if(var == NULL) {
2943 var1 = 0;
2944 } else {
2945 if(cltype >= var->type->table_size) {
2946 var1 = 0;
2947 } else {
2948 var1 = var->type->type_table[cltype] == idtype;
2949 }
2950 }
2951 if (!var1) {
2952 var_class_name = var == NULL ? "null" : var->type->name;
2953 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
2954 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 473);
2955 show_backtrace(1);
2956 }
2957 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var) /* add_type on <var_v:RapidTypeVisitor>*/;
2958 RET_LABEL:;
2959 }
2960 /* method rapid_type_analysis#ACharExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */
2961 void VIRTUAL_rapid_type_analysis__ACharExpr__accept_rapid_type_visitor(val* self, val* p0) {
2962 rapid_type_analysis__ACharExpr__accept_rapid_type_visitor(self, p0);
2963 RET_LABEL:;
2964 }
2965 /* method rapid_type_analysis#AArrayExpr#accept_rapid_type_visitor for (self: AArrayExpr, RapidTypeVisitor) */
2966 void rapid_type_analysis__AArrayExpr__accept_rapid_type_visitor(val* self, val* p0) {
2967 val* var_v /* var v: RapidTypeVisitor */;
2968 val* var /* : nullable MType */;
2969 short int var1 /* : Bool */;
2970 int cltype;
2971 int idtype;
2972 const char* var_class_name;
2973 val* var_mtype /* var mtype: MClassType */;
2974 val* var2 /* : RapidTypeAnalysis */;
2975 val* var3 /* : MModule */;
2976 static val* varonce;
2977 val* var4 /* : String */;
2978 char* var5 /* : NativeString */;
2979 long var6 /* : Int */;
2980 val* var7 /* : String */;
2981 val* var8 /* : MClass */;
2982 val* var9 /* : Array[MType] */;
2983 val* var10 /* : nullable Object */;
2984 val* var11 /* : Array[MType] */;
2985 long var12 /* : Int */;
2986 val* var13 /* : NativeArray[MType] */;
2987 val* var14 /* : MClassType */;
2988 val* var_native /* var native: MClassType */;
2989 val* var15 /* : nullable MClassType */;
2990 static val* varonce16;
2991 val* var17 /* : String */;
2992 char* var18 /* : NativeString */;
2993 long var19 /* : Int */;
2994 val* var20 /* : String */;
2995 val* var21 /* : MMethod */;
2996 val* var_prop /* var prop: MMethod */;
2997 var_v = p0;
2998 var = ((val* (*)(val*))(self->class->vft[COLOR_typing__AExpr__mtype]))(self) /* mtype on <self:AArrayExpr>*/;
2999 /* <var:nullable MType> isa MClassType */
3000 cltype = type_model__MClassType.color;
3001 idtype = type_model__MClassType.id;
3002 if(var == NULL) {
3003 var1 = 0;
3004 } else {
3005 if(cltype >= var->type->table_size) {
3006 var1 = 0;
3007 } else {
3008 var1 = var->type->type_table[cltype] == idtype;
3009 }
3010 }
3011 if (!var1) {
3012 var_class_name = var == NULL ? "null" : var->type->name;
3013 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
3014 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 480);
3015 show_backtrace(1);
3016 }
3017 var_mtype = var;
3018 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var_mtype) /* add_type on <var_v:RapidTypeVisitor>*/;
3019 var2 = ((val* (*)(val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__analysis]))(var_v) /* analysis on <var_v:RapidTypeVisitor>*/;
3020 var3 = ((val* (*)(val*))(var2->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__mainmodule]))(var2) /* mainmodule on <var2:RapidTypeAnalysis>*/;
3021 if (varonce) {
3022 var4 = varonce;
3023 } else {
3024 var5 = "NativeArray";
3025 var6 = 11;
3026 var7 = string__NativeString__to_s_with_length(var5, var6);
3027 var4 = var7;
3028 varonce = var4;
3029 }
3030 var8 = ((val* (*)(val*, val*))(var3->class->vft[COLOR_model__MModule__get_primitive_class]))(var3, var4) /* get_primitive_class on <var3:MModule>*/;
3031 var9 = ((val* (*)(val*))(var_mtype->class->vft[COLOR_model__MClassType__arguments]))(var_mtype) /* arguments on <var_mtype:MClassType>*/;
3032 var10 = ((val* (*)(val*))(var9->class->vft[COLOR_abstract_collection__Collection__first]))(var9) /* first on <var9:Array[MType]>*/;
3033 var11 = NEW_array__Array(&type_array__Arraymodel__MType);
3034 { /* var11 = array_instance Array[MType] */
3035 var12 = 1;
3036 var13 = NEW_array__NativeArray(var12, &type_array__NativeArraymodel__MType);
3037 ((struct instance_array__NativeArray*)var13)->values[0] = (val*) var10;
3038 ((void (*)(val*, val*, long))(var11->class->vft[COLOR_array__Array__with_native]))(var11, var13, var12) /* with_native on <var11:Array[MType]>*/;
3039 }
3040 var14 = ((val* (*)(val*, val*))(var8->class->vft[COLOR_model__MClass__get_mtype]))(var8, var11) /* get_mtype on <var8:MClass>*/;
3041 var_native = var14;
3042 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var_native) /* add_type on <var_v:RapidTypeVisitor>*/;
3043 var15 = ((val* (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__cleanup_type]))(var_v, var_mtype) /* cleanup_type on <var_v:RapidTypeVisitor>*/;
3044 if (var15 == NULL) {
3045 fprintf(stderr, "Runtime error: %s", "Cast failed");
3046 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 484);
3047 show_backtrace(1);
3048 }
3049 var_mtype = var15;
3050 if (varonce16) {
3051 var17 = varonce16;
3052 } else {
3053 var18 = "with_native";
3054 var19 = 11;
3055 var20 = string__NativeString__to_s_with_length(var18, var19);
3056 var17 = var20;
3057 varonce16 = var17;
3058 }
3059 var21 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__get_method]))(var_v, var_mtype, var17) /* get_method on <var_v:RapidTypeVisitor>*/;
3060 var_prop = var21;
3061 ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_monomorphic_send]))(var_v, var_mtype, var_prop) /* add_monomorphic_send on <var_v:RapidTypeVisitor>*/;
3062 RET_LABEL:;
3063 }
3064 /* method rapid_type_analysis#AArrayExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */
3065 void VIRTUAL_rapid_type_analysis__AArrayExpr__accept_rapid_type_visitor(val* self, val* p0) {
3066 rapid_type_analysis__AArrayExpr__accept_rapid_type_visitor(self, p0);
3067 RET_LABEL:;
3068 }
3069 /* method rapid_type_analysis#AStringFormExpr#accept_rapid_type_visitor for (self: AStringFormExpr, RapidTypeVisitor) */
3070 void rapid_type_analysis__AStringFormExpr__accept_rapid_type_visitor(val* self, val* p0) {
3071 val* var_v /* var v: RapidTypeVisitor */;
3072 static val* varonce;
3073 val* var /* : String */;
3074 char* var1 /* : NativeString */;
3075 long var2 /* : Int */;
3076 val* var3 /* : String */;
3077 val* var4 /* : MClass */;
3078 val* var5 /* : MClassType */;
3079 val* var_native /* var native: MClassType */;
3080 static val* varonce6;
3081 val* var7 /* : String */;
3082 char* var8 /* : NativeString */;
3083 long var9 /* : Int */;
3084 val* var10 /* : String */;
3085 val* var11 /* : MMethod */;
3086 val* var_prop /* var prop: MMethod */;
3087 var_v = p0;
3088 if (varonce) {
3089 var = varonce;
3090 } else {
3091 var1 = "NativeString";
3092 var2 = 12;
3093 var3 = string__NativeString__to_s_with_length(var1, var2);
3094 var = var3;
3095 varonce = var;
3096 }
3097 var4 = ((val* (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__get_class]))(var_v, var) /* get_class on <var_v:RapidTypeVisitor>*/;
3098 var5 = ((val* (*)(val*))(var4->class->vft[COLOR_model__MClass__mclass_type]))(var4) /* mclass_type on <var4:MClass>*/;
3099 var_native = var5;
3100 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var_native) /* add_type on <var_v:RapidTypeVisitor>*/;
3101 if (varonce6) {
3102 var7 = varonce6;
3103 } else {
3104 var8 = "to_s_with_length";
3105 var9 = 16;
3106 var10 = string__NativeString__to_s_with_length(var8, var9);
3107 var7 = var10;
3108 varonce6 = var7;
3109 }
3110 var11 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__get_method]))(var_v, var_native, var7) /* get_method on <var_v:RapidTypeVisitor>*/;
3111 var_prop = var11;
3112 ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_monomorphic_send]))(var_v, var_native, var_prop) /* add_monomorphic_send on <var_v:RapidTypeVisitor>*/;
3113 RET_LABEL:;
3114 }
3115 /* method rapid_type_analysis#AStringFormExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */
3116 void VIRTUAL_rapid_type_analysis__AStringFormExpr__accept_rapid_type_visitor(val* self, val* p0) {
3117 rapid_type_analysis__AStringFormExpr__accept_rapid_type_visitor(self, p0);
3118 RET_LABEL:;
3119 }
3120 /* method rapid_type_analysis#ASuperstringExpr#accept_rapid_type_visitor for (self: ASuperstringExpr, RapidTypeVisitor) */
3121 void rapid_type_analysis__ASuperstringExpr__accept_rapid_type_visitor(val* self, val* p0) {
3122 val* var_v /* var v: RapidTypeVisitor */;
3123 static val* varonce;
3124 val* var /* : String */;
3125 char* var1 /* : NativeString */;
3126 long var2 /* : Int */;
3127 val* var3 /* : String */;
3128 val* var4 /* : MClass */;
3129 static val* varonce5;
3130 val* var6 /* : String */;
3131 char* var7 /* : NativeString */;
3132 long var8 /* : Int */;
3133 val* var9 /* : String */;
3134 val* var10 /* : MClass */;
3135 val* var11 /* : MClassType */;
3136 val* var12 /* : Array[MClassType] */;
3137 long var13 /* : Int */;
3138 val* var14 /* : NativeArray[MClassType] */;
3139 val* var15 /* : MClassType */;
3140 val* var_arraytype /* var arraytype: MClassType */;
3141 static val* varonce16;
3142 val* var17 /* : String */;
3143 char* var18 /* : NativeString */;
3144 long var19 /* : Int */;
3145 val* var20 /* : String */;
3146 val* var21 /* : MClass */;
3147 static val* varonce22;
3148 val* var23 /* : String */;
3149 char* var24 /* : NativeString */;
3150 long var25 /* : Int */;
3151 val* var26 /* : String */;
3152 val* var27 /* : MClass */;
3153 val* var28 /* : MClassType */;
3154 val* var29 /* : Array[MClassType] */;
3155 long var30 /* : Int */;
3156 val* var31 /* : NativeArray[MClassType] */;
3157 val* var32 /* : MClassType */;
3158 static val* varonce33;
3159 val* var34 /* : String */;
3160 char* var35 /* : NativeString */;
3161 long var36 /* : Int */;
3162 val* var37 /* : String */;
3163 val* var38 /* : MMethod */;
3164 val* var_prop /* var prop: MMethod */;
3165 static val* varonce39;
3166 val* var40 /* : String */;
3167 char* var41 /* : NativeString */;
3168 long var42 /* : Int */;
3169 val* var43 /* : String */;
3170 val* var44 /* : MMethod */;
3171 val* var_prop2 /* var prop2: MMethod */;
3172 var_v = p0;
3173 if (varonce) {
3174 var = varonce;
3175 } else {
3176 var1 = "Array";
3177 var2 = 5;
3178 var3 = string__NativeString__to_s_with_length(var1, var2);
3179 var = var3;
3180 varonce = var;
3181 }
3182 var4 = ((val* (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__get_class]))(var_v, var) /* get_class on <var_v:RapidTypeVisitor>*/;
3183 if (varonce5) {
3184 var6 = varonce5;
3185 } else {
3186 var7 = "Object";
3187 var8 = 6;
3188 var9 = string__NativeString__to_s_with_length(var7, var8);
3189 var6 = var9;
3190 varonce5 = var6;
3191 }
3192 var10 = ((val* (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__get_class]))(var_v, var6) /* get_class on <var_v:RapidTypeVisitor>*/;
3193 var11 = ((val* (*)(val*))(var10->class->vft[COLOR_model__MClass__mclass_type]))(var10) /* mclass_type on <var10:MClass>*/;
3194 var12 = NEW_array__Array(&type_array__Arraymodel__MClassType);
3195 { /* var12 = array_instance Array[MClassType] */
3196 var13 = 1;
3197 var14 = NEW_array__NativeArray(var13, &type_array__NativeArraymodel__MClassType);
3198 ((struct instance_array__NativeArray*)var14)->values[0] = (val*) var11;
3199 ((void (*)(val*, val*, long))(var12->class->vft[COLOR_array__Array__with_native]))(var12, var14, var13) /* with_native on <var12:Array[MClassType]>*/;
3200 }
3201 var15 = ((val* (*)(val*, val*))(var4->class->vft[COLOR_model__MClass__get_mtype]))(var4, var12) /* get_mtype on <var4:MClass>*/;
3202 var_arraytype = var15;
3203 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var_arraytype) /* add_type on <var_v:RapidTypeVisitor>*/;
3204 if (varonce16) {
3205 var17 = varonce16;
3206 } else {
3207 var18 = "NativeArray";
3208 var19 = 11;
3209 var20 = string__NativeString__to_s_with_length(var18, var19);
3210 var17 = var20;
3211 varonce16 = var17;
3212 }
3213 var21 = ((val* (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__get_class]))(var_v, var17) /* get_class on <var_v:RapidTypeVisitor>*/;
3214 if (varonce22) {
3215 var23 = varonce22;
3216 } else {
3217 var24 = "Object";
3218 var25 = 6;
3219 var26 = string__NativeString__to_s_with_length(var24, var25);
3220 var23 = var26;
3221 varonce22 = var23;
3222 }
3223 var27 = ((val* (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__get_class]))(var_v, var23) /* get_class on <var_v:RapidTypeVisitor>*/;
3224 var28 = ((val* (*)(val*))(var27->class->vft[COLOR_model__MClass__mclass_type]))(var27) /* mclass_type on <var27:MClass>*/;
3225 var29 = NEW_array__Array(&type_array__Arraymodel__MClassType);
3226 { /* var29 = array_instance Array[MClassType] */
3227 var30 = 1;
3228 var31 = NEW_array__NativeArray(var30, &type_array__NativeArraymodel__MClassType);
3229 ((struct instance_array__NativeArray*)var31)->values[0] = (val*) var28;
3230 ((void (*)(val*, val*, long))(var29->class->vft[COLOR_array__Array__with_native]))(var29, var31, var30) /* with_native on <var29:Array[MClassType]>*/;
3231 }
3232 var32 = ((val* (*)(val*, val*))(var21->class->vft[COLOR_model__MClass__get_mtype]))(var21, var29) /* get_mtype on <var21:MClass>*/;
3233 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var32) /* add_type on <var_v:RapidTypeVisitor>*/;
3234 if (varonce33) {
3235 var34 = varonce33;
3236 } else {
3237 var35 = "join";
3238 var36 = 4;
3239 var37 = string__NativeString__to_s_with_length(var35, var36);
3240 var34 = var37;
3241 varonce33 = var34;
3242 }
3243 var38 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__get_method]))(var_v, var_arraytype, var34) /* get_method on <var_v:RapidTypeVisitor>*/;
3244 var_prop = var38;
3245 ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_monomorphic_send]))(var_v, var_arraytype, var_prop) /* add_monomorphic_send on <var_v:RapidTypeVisitor>*/;
3246 if (varonce39) {
3247 var40 = varonce39;
3248 } else {
3249 var41 = "with_native";
3250 var42 = 11;
3251 var43 = string__NativeString__to_s_with_length(var41, var42);
3252 var40 = var43;
3253 varonce39 = var40;
3254 }
3255 var44 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__get_method]))(var_v, var_arraytype, var40) /* get_method on <var_v:RapidTypeVisitor>*/;
3256 var_prop2 = var44;
3257 ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_monomorphic_send]))(var_v, var_arraytype, var_prop2) /* add_monomorphic_send on <var_v:RapidTypeVisitor>*/;
3258 RET_LABEL:;
3259 }
3260 /* method rapid_type_analysis#ASuperstringExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */
3261 void VIRTUAL_rapid_type_analysis__ASuperstringExpr__accept_rapid_type_visitor(val* self, val* p0) {
3262 rapid_type_analysis__ASuperstringExpr__accept_rapid_type_visitor(self, p0);
3263 RET_LABEL:;
3264 }
3265 /* method rapid_type_analysis#ACrangeExpr#accept_rapid_type_visitor for (self: ACrangeExpr, RapidTypeVisitor) */
3266 void rapid_type_analysis__ACrangeExpr__accept_rapid_type_visitor(val* self, val* p0) {
3267 val* var_v /* var v: RapidTypeVisitor */;
3268 val* var /* : nullable MType */;
3269 short int var1 /* : Bool */;
3270 int cltype;
3271 int idtype;
3272 const char* var_class_name;
3273 val* var_mtype /* var mtype: MClassType */;
3274 static val* varonce;
3275 val* var2 /* : String */;
3276 char* var3 /* : NativeString */;
3277 long var4 /* : Int */;
3278 val* var5 /* : String */;
3279 val* var6 /* : MMethod */;
3280 val* var_prop /* var prop: MMethod */;
3281 var_v = p0;
3282 var = ((val* (*)(val*))(self->class->vft[COLOR_typing__AExpr__mtype]))(self) /* mtype on <self:ACrangeExpr>*/;
3283 /* <var:nullable MType> isa MClassType */
3284 cltype = type_model__MClassType.color;
3285 idtype = type_model__MClassType.id;
3286 if(var == NULL) {
3287 var1 = 0;
3288 } else {
3289 if(cltype >= var->type->table_size) {
3290 var1 = 0;
3291 } else {
3292 var1 = var->type->type_table[cltype] == idtype;
3293 }
3294 }
3295 if (!var1) {
3296 var_class_name = var == NULL ? "null" : var->type->name;
3297 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
3298 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 516);
3299 show_backtrace(1);
3300 }
3301 var_mtype = var;
3302 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var_mtype) /* add_type on <var_v:RapidTypeVisitor>*/;
3303 if (varonce) {
3304 var2 = varonce;
3305 } else {
3306 var3 = "init";
3307 var4 = 4;
3308 var5 = string__NativeString__to_s_with_length(var3, var4);
3309 var2 = var5;
3310 varonce = var2;
3311 }
3312 var6 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__get_method]))(var_v, var_mtype, var2) /* get_method on <var_v:RapidTypeVisitor>*/;
3313 var_prop = var6;
3314 ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_monomorphic_send]))(var_v, var_mtype, var_prop) /* add_monomorphic_send on <var_v:RapidTypeVisitor>*/;
3315 RET_LABEL:;
3316 }
3317 /* method rapid_type_analysis#ACrangeExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */
3318 void VIRTUAL_rapid_type_analysis__ACrangeExpr__accept_rapid_type_visitor(val* self, val* p0) {
3319 rapid_type_analysis__ACrangeExpr__accept_rapid_type_visitor(self, p0);
3320 RET_LABEL:;
3321 }
3322 /* method rapid_type_analysis#AOrangeExpr#accept_rapid_type_visitor for (self: AOrangeExpr, RapidTypeVisitor) */
3323 void rapid_type_analysis__AOrangeExpr__accept_rapid_type_visitor(val* self, val* p0) {
3324 val* var_v /* var v: RapidTypeVisitor */;
3325 val* var /* : nullable MType */;
3326 short int var1 /* : Bool */;
3327 int cltype;
3328 int idtype;
3329 const char* var_class_name;
3330 val* var_mtype /* var mtype: MClassType */;
3331 static val* varonce;
3332 val* var2 /* : String */;
3333 char* var3 /* : NativeString */;
3334 long var4 /* : Int */;
3335 val* var5 /* : String */;
3336 val* var6 /* : MMethod */;
3337 val* var_prop /* var prop: MMethod */;
3338 var_v = p0;
3339 var = ((val* (*)(val*))(self->class->vft[COLOR_typing__AExpr__mtype]))(self) /* mtype on <self:AOrangeExpr>*/;
3340 /* <var:nullable MType> isa MClassType */
3341 cltype = type_model__MClassType.color;
3342 idtype = type_model__MClassType.id;
3343 if(var == NULL) {
3344 var1 = 0;
3345 } else {
3346 if(cltype >= var->type->table_size) {
3347 var1 = 0;
3348 } else {
3349 var1 = var->type->type_table[cltype] == idtype;
3350 }
3351 }
3352 if (!var1) {
3353 var_class_name = var == NULL ? "null" : var->type->name;
3354 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
3355 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 526);
3356 show_backtrace(1);
3357 }
3358 var_mtype = var;
3359 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var_mtype) /* add_type on <var_v:RapidTypeVisitor>*/;
3360 if (varonce) {
3361 var2 = varonce;
3362 } else {
3363 var3 = "without_last";
3364 var4 = 12;
3365 var5 = string__NativeString__to_s_with_length(var3, var4);
3366 var2 = var5;
3367 varonce = var2;
3368 }
3369 var6 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__get_method]))(var_v, var_mtype, var2) /* get_method on <var_v:RapidTypeVisitor>*/;
3370 var_prop = var6;
3371 ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_monomorphic_send]))(var_v, var_mtype, var_prop) /* add_monomorphic_send on <var_v:RapidTypeVisitor>*/;
3372 RET_LABEL:;
3373 }
3374 /* method rapid_type_analysis#AOrangeExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */
3375 void VIRTUAL_rapid_type_analysis__AOrangeExpr__accept_rapid_type_visitor(val* self, val* p0) {
3376 rapid_type_analysis__AOrangeExpr__accept_rapid_type_visitor(self, p0);
3377 RET_LABEL:;
3378 }
3379 /* method rapid_type_analysis#ATrueExpr#accept_rapid_type_visitor for (self: ATrueExpr, RapidTypeVisitor) */
3380 void rapid_type_analysis__ATrueExpr__accept_rapid_type_visitor(val* self, val* p0) {
3381 val* var_v /* var v: RapidTypeVisitor */;
3382 val* var /* : nullable MType */;
3383 short int var1 /* : Bool */;
3384 int cltype;
3385 int idtype;
3386 const char* var_class_name;
3387 var_v = p0;
3388 var = ((val* (*)(val*))(self->class->vft[COLOR_typing__AExpr__mtype]))(self) /* mtype on <self:ATrueExpr>*/;
3389 /* <var:nullable MType> isa MClassType */
3390 cltype = type_model__MClassType.color;
3391 idtype = type_model__MClassType.id;
3392 if(var == NULL) {
3393 var1 = 0;
3394 } else {
3395 if(cltype >= var->type->table_size) {
3396 var1 = 0;
3397 } else {
3398 var1 = var->type->type_table[cltype] == idtype;
3399 }
3400 }
3401 if (!var1) {
3402 var_class_name = var == NULL ? "null" : var->type->name;
3403 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
3404 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 536);
3405 show_backtrace(1);
3406 }
3407 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var) /* add_type on <var_v:RapidTypeVisitor>*/;
3408 RET_LABEL:;
3409 }
3410 /* method rapid_type_analysis#ATrueExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */
3411 void VIRTUAL_rapid_type_analysis__ATrueExpr__accept_rapid_type_visitor(val* self, val* p0) {
3412 rapid_type_analysis__ATrueExpr__accept_rapid_type_visitor(self, p0);
3413 RET_LABEL:;
3414 }
3415 /* method rapid_type_analysis#AFalseExpr#accept_rapid_type_visitor for (self: AFalseExpr, RapidTypeVisitor) */
3416 void rapid_type_analysis__AFalseExpr__accept_rapid_type_visitor(val* self, val* p0) {
3417 val* var_v /* var v: RapidTypeVisitor */;
3418 val* var /* : nullable MType */;
3419 short int var1 /* : Bool */;
3420 int cltype;
3421 int idtype;
3422 const char* var_class_name;
3423 var_v = p0;
3424 var = ((val* (*)(val*))(self->class->vft[COLOR_typing__AExpr__mtype]))(self) /* mtype on <self:AFalseExpr>*/;
3425 /* <var:nullable MType> isa MClassType */
3426 cltype = type_model__MClassType.color;
3427 idtype = type_model__MClassType.id;
3428 if(var == NULL) {
3429 var1 = 0;
3430 } else {
3431 if(cltype >= var->type->table_size) {
3432 var1 = 0;
3433 } else {
3434 var1 = var->type->type_table[cltype] == idtype;
3435 }
3436 }
3437 if (!var1) {
3438 var_class_name = var == NULL ? "null" : var->type->name;
3439 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
3440 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 543);
3441 show_backtrace(1);
3442 }
3443 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var) /* add_type on <var_v:RapidTypeVisitor>*/;
3444 RET_LABEL:;
3445 }
3446 /* method rapid_type_analysis#AFalseExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */
3447 void VIRTUAL_rapid_type_analysis__AFalseExpr__accept_rapid_type_visitor(val* self, val* p0) {
3448 rapid_type_analysis__AFalseExpr__accept_rapid_type_visitor(self, p0);
3449 RET_LABEL:;
3450 }
3451 /* method rapid_type_analysis#AIsaExpr#accept_rapid_type_visitor for (self: AIsaExpr, RapidTypeVisitor) */
3452 void rapid_type_analysis__AIsaExpr__accept_rapid_type_visitor(val* self, val* p0) {
3453 val* var_v /* var v: RapidTypeVisitor */;
3454 val* var /* : nullable MType */;
3455 var_v = p0;
3456 var = ((val* (*)(val*))(self->class->vft[COLOR_typing__AIsaExpr__cast_type]))(self) /* cast_type on <self:AIsaExpr>*/;
3457 if (var == NULL) {
3458 fprintf(stderr, "Runtime error: %s", "Cast failed");
3459 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 550);
3460 show_backtrace(1);
3461 }
3462 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_cast_type]))(var_v, var) /* add_cast_type on <var_v:RapidTypeVisitor>*/;
3463 RET_LABEL:;
3464 }
3465 /* method rapid_type_analysis#AIsaExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */
3466 void VIRTUAL_rapid_type_analysis__AIsaExpr__accept_rapid_type_visitor(val* self, val* p0) {
3467 rapid_type_analysis__AIsaExpr__accept_rapid_type_visitor(self, p0);
3468 RET_LABEL:;
3469 }
3470 /* method rapid_type_analysis#AAsCastExpr#accept_rapid_type_visitor for (self: AAsCastExpr, RapidTypeVisitor) */
3471 void rapid_type_analysis__AAsCastExpr__accept_rapid_type_visitor(val* self, val* p0) {
3472 val* var_v /* var v: RapidTypeVisitor */;
3473 val* var /* : nullable MType */;
3474 var_v = p0;
3475 var = ((val* (*)(val*))(self->class->vft[COLOR_typing__AExpr__mtype]))(self) /* mtype on <self:AAsCastExpr>*/;
3476 if (var == NULL) {
3477 fprintf(stderr, "Runtime error: %s", "Cast failed");
3478 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 557);
3479 show_backtrace(1);
3480 }
3481 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_cast_type]))(var_v, var) /* add_cast_type on <var_v:RapidTypeVisitor>*/;
3482 RET_LABEL:;
3483 }
3484 /* method rapid_type_analysis#AAsCastExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */
3485 void VIRTUAL_rapid_type_analysis__AAsCastExpr__accept_rapid_type_visitor(val* self, val* p0) {
3486 rapid_type_analysis__AAsCastExpr__accept_rapid_type_visitor(self, p0);
3487 RET_LABEL:;
3488 }
3489 /* method rapid_type_analysis#ASendExpr#accept_rapid_type_visitor for (self: ASendExpr, RapidTypeVisitor) */
3490 void rapid_type_analysis__ASendExpr__accept_rapid_type_visitor(val* self, val* p0) {
3491 val* var_v /* var v: RapidTypeVisitor */;
3492 val* var /* : nullable CallSite */;
3493 var_v = p0;
3494 var = ((val* (*)(val*))(self->class->vft[COLOR_typing__ASendExpr__callsite]))(self) /* callsite on <self:ASendExpr>*/;
3495 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_callsite]))(var_v, var) /* add_callsite on <var_v:RapidTypeVisitor>*/;
3496 RET_LABEL:;
3497 }
3498 /* method rapid_type_analysis#ASendExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */
3499 void VIRTUAL_rapid_type_analysis__ASendExpr__accept_rapid_type_visitor(val* self, val* p0) {
3500 rapid_type_analysis__ASendExpr__accept_rapid_type_visitor(self, p0);
3501 RET_LABEL:;
3502 }
3503 /* method rapid_type_analysis#ASendReassignFormExpr#accept_rapid_type_visitor for (self: ASendReassignFormExpr, RapidTypeVisitor) */
3504 void rapid_type_analysis__ASendReassignFormExpr__accept_rapid_type_visitor(val* self, val* p0) {
3505 val* var_v /* var v: RapidTypeVisitor */;
3506 val* var /* : nullable CallSite */;
3507 val* var1 /* : nullable CallSite */;
3508 val* var2 /* : nullable CallSite */;
3509 var_v = p0;
3510 var = ((val* (*)(val*))(self->class->vft[COLOR_typing__ASendExpr__callsite]))(self) /* callsite on <self:ASendReassignFormExpr>*/;
3511 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_callsite]))(var_v, var) /* add_callsite on <var_v:RapidTypeVisitor>*/;
3512 var1 = ((val* (*)(val*))(self->class->vft[COLOR_typing__AReassignFormExpr__reassign_callsite]))(self) /* reassign_callsite on <self:ASendReassignFormExpr>*/;
3513 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_callsite]))(var_v, var1) /* add_callsite on <var_v:RapidTypeVisitor>*/;
3514 var2 = ((val* (*)(val*))(self->class->vft[COLOR_typing__ASendReassignFormExpr__write_callsite]))(self) /* write_callsite on <self:ASendReassignFormExpr>*/;
3515 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_callsite]))(var_v, var2) /* add_callsite on <var_v:RapidTypeVisitor>*/;
3516 RET_LABEL:;
3517 }
3518 /* method rapid_type_analysis#ASendReassignFormExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */
3519 void VIRTUAL_rapid_type_analysis__ASendReassignFormExpr__accept_rapid_type_visitor(val* self, val* p0) {
3520 rapid_type_analysis__ASendReassignFormExpr__accept_rapid_type_visitor(self, p0);
3521 RET_LABEL:;
3522 }
3523 /* method rapid_type_analysis#AVarReassignExpr#accept_rapid_type_visitor for (self: AVarReassignExpr, RapidTypeVisitor) */
3524 void rapid_type_analysis__AVarReassignExpr__accept_rapid_type_visitor(val* self, val* p0) {
3525 val* var_v /* var v: RapidTypeVisitor */;
3526 val* var /* : nullable CallSite */;
3527 var_v = p0;
3528 var = ((val* (*)(val*))(self->class->vft[COLOR_typing__AReassignFormExpr__reassign_callsite]))(self) /* reassign_callsite on <self:AVarReassignExpr>*/;
3529 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_callsite]))(var_v, var) /* add_callsite on <var_v:RapidTypeVisitor>*/;
3530 RET_LABEL:;
3531 }
3532 /* method rapid_type_analysis#AVarReassignExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */
3533 void VIRTUAL_rapid_type_analysis__AVarReassignExpr__accept_rapid_type_visitor(val* self, val* p0) {
3534 rapid_type_analysis__AVarReassignExpr__accept_rapid_type_visitor(self, p0);
3535 RET_LABEL:;
3536 }
3537 /* method rapid_type_analysis#AAttrReassignExpr#accept_rapid_type_visitor for (self: AAttrReassignExpr, RapidTypeVisitor) */
3538 void rapid_type_analysis__AAttrReassignExpr__accept_rapid_type_visitor(val* self, val* p0) {
3539 val* var_v /* var v: RapidTypeVisitor */;
3540 val* var /* : nullable CallSite */;
3541 var_v = p0;
3542 var = ((val* (*)(val*))(self->class->vft[COLOR_typing__AReassignFormExpr__reassign_callsite]))(self) /* reassign_callsite on <self:AAttrReassignExpr>*/;
3543 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_callsite]))(var_v, var) /* add_callsite on <var_v:RapidTypeVisitor>*/;
3544 RET_LABEL:;
3545 }
3546 /* method rapid_type_analysis#AAttrReassignExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */
3547 void VIRTUAL_rapid_type_analysis__AAttrReassignExpr__accept_rapid_type_visitor(val* self, val* p0) {
3548 rapid_type_analysis__AAttrReassignExpr__accept_rapid_type_visitor(self, p0);
3549 RET_LABEL:;
3550 }
3551 /* method rapid_type_analysis#ASuperExpr#accept_rapid_type_visitor for (self: ASuperExpr, RapidTypeVisitor) */
3552 void rapid_type_analysis__ASuperExpr__accept_rapid_type_visitor(val* self, val* p0) {
3553 val* var_v /* var v: RapidTypeVisitor */;
3554 val* var /* : nullable CallSite */;
3555 val* var_callsite /* var callsite: nullable CallSite */;
3556 val* var1 /* : null */;
3557 short int var2 /* : Bool */;
3558 val* var3 /* : RapidTypeAnalysis */;
3559 val* var4 /* : MClassType */;
3560 val* var5 /* : nullable MMethodDef */;
3561 var_v = p0;
3562 var = ((val* (*)(val*))(self->class->vft[COLOR_typing__ASuperExpr__callsite]))(self) /* callsite on <self:ASuperExpr>*/;
3563 var_callsite = var;
3564 var1 = NULL;
3565 if (var_callsite == NULL) {
3566 var2 = 0; /* is null */
3567 } else {
3568 var2 = 1; /* arg is null and recv is not */
3569 }
3570 if (var2){
3571 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_callsite]))(var_v, var_callsite) /* add_callsite on <var_v:RapidTypeVisitor>*/;
3572 goto RET_LABEL;
3573 } else {
3574 }
3575 var3 = ((val* (*)(val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__analysis]))(var_v) /* analysis on <var_v:RapidTypeVisitor>*/;
3576 var4 = ((val* (*)(val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__receiver]))(var_v) /* receiver on <var_v:RapidTypeVisitor>*/;
3577 var5 = ((val* (*)(val*))(self->class->vft[COLOR_typing__ASuperExpr__mpropdef]))(self) /* mpropdef on <self:ASuperExpr>*/;
3578 if (var5 == NULL) {
3579 fprintf(stderr, "Runtime error: %s", "Cast failed");
3580 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 601);
3581 show_backtrace(1);
3582 }
3583 ((void (*)(val*, val*, val*))(var3->class->vft[COLOR_rapid_type_analysis__RapidTypeAnalysis__add_super_send]))(var3, var4, var5) /* add_super_send on <var3:RapidTypeAnalysis>*/;
3584 RET_LABEL:;
3585 }
3586 /* method rapid_type_analysis#ASuperExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */
3587 void VIRTUAL_rapid_type_analysis__ASuperExpr__accept_rapid_type_visitor(val* self, val* p0) {
3588 rapid_type_analysis__ASuperExpr__accept_rapid_type_visitor(self, p0);
3589 RET_LABEL:;
3590 }
3591 /* method rapid_type_analysis#AForExpr#accept_rapid_type_visitor for (self: AForExpr, RapidTypeVisitor) */
3592 void rapid_type_analysis__AForExpr__accept_rapid_type_visitor(val* self, val* p0) {
3593 val* var_v /* var v: RapidTypeVisitor */;
3594 val* var /* : AExpr */;
3595 val* var1 /* : nullable MType */;
3596 val* var_recvtype /* var recvtype: MType */;
3597 val* var2 /* : nullable MClassType */;
3598 val* var_colltype /* var colltype: MClassType */;
3599 static val* varonce;
3600 val* var3 /* : String */;
3601 char* var4 /* : NativeString */;
3602 long var5 /* : Int */;
3603 val* var6 /* : String */;
3604 val* var7 /* : MMethod */;
3605 val* var_itmeth /* var itmeth: MMethod */;
3606 val* var8 /* : MPropDef */;
3607 val* var9 /* : nullable MSignature */;
3608 val* var10 /* : nullable MType */;
3609 short int var11 /* : Bool */;
3610 int cltype;
3611 int idtype;
3612 const char* var_class_name;
3613 val* var12 /* : MClass */;
3614 val* var13 /* : MClassDef */;
3615 val* var14 /* : MClassType */;
3616 val* var_iteratortype /* var iteratortype: MClassType */;
3617 static val* varonce15;
3618 val* var16 /* : String */;
3619 char* var17 /* : NativeString */;
3620 long var18 /* : Int */;
3621 val* var19 /* : String */;
3622 val* var20 /* : MClass */;
3623 val* var21 /* : MClassType */;
3624 val* var_objtype /* var objtype: MClassType */;
3625 static val* varonce22;
3626 val* var23 /* : String */;
3627 char* var24 /* : NativeString */;
3628 long var25 /* : Int */;
3629 val* var26 /* : String */;
3630 val* var27 /* : MMethod */;
3631 val* var28 /* : nullable Array[Variable] */;
3632 long var29 /* : Int */;
3633 long var30 /* : Int */;
3634 short int var31 /* : Bool */;
3635 short int var33 /* : Bool */;
3636 static val* varonce34;
3637 val* var35 /* : String */;
3638 char* var36 /* : NativeString */;
3639 long var37 /* : Int */;
3640 val* var38 /* : String */;
3641 val* var39 /* : MMethod */;
3642 val* var40 /* : nullable Array[Variable] */;
3643 long var41 /* : Int */;
3644 long var42 /* : Int */;
3645 short int var43 /* : Bool */;
3646 short int var45 /* : Bool */;
3647 static val* varonce46;
3648 val* var47 /* : String */;
3649 char* var48 /* : NativeString */;
3650 long var49 /* : Int */;
3651 val* var50 /* : String */;
3652 val* var51 /* : MMethod */;
3653 static val* varonce52;
3654 val* var53 /* : String */;
3655 char* var54 /* : NativeString */;
3656 long var55 /* : Int */;
3657 val* var56 /* : String */;
3658 val* var57 /* : MMethod */;
3659 static val* varonce58;
3660 val* var59 /* : String */;
3661 char* var60 /* : NativeString */;
3662 long var61 /* : Int */;
3663 val* var62 /* : String */;
3664 val* var63 /* : MMethod */;
3665 var_v = p0;
3666 var = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__AForExpr__n_expr]))(self) /* n_expr on <self:AForExpr>*/;
3667 var1 = ((val* (*)(val*))(var->class->vft[COLOR_typing__AExpr__mtype]))(var) /* mtype on <var:AExpr>*/;
3668 if (var1 == NULL) {
3669 fprintf(stderr, "Runtime error: %s", "Cast failed");
3670 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 608);
3671 show_backtrace(1);
3672 }
3673 var_recvtype = var1;
3674 var2 = ((val* (*)(val*))(self->class->vft[COLOR_typing__AForExpr__coltype]))(self) /* coltype on <self:AForExpr>*/;
3675 if (var2 == NULL) {
3676 fprintf(stderr, "Runtime error: %s", "Cast failed");
3677 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 609);
3678 show_backtrace(1);
3679 }
3680 var_colltype = var2;
3681 if (varonce) {
3682 var3 = varonce;
3683 } else {
3684 var4 = "iterator";
3685 var5 = 8;
3686 var6 = string__NativeString__to_s_with_length(var4, var5);
3687 var3 = var6;
3688 varonce = var3;
3689 }
3690 var7 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__get_method]))(var_v, var_colltype, var3) /* get_method on <var_v:RapidTypeVisitor>*/;
3691 var_itmeth = var7;
3692 ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_send]))(var_v, var_recvtype, var_itmeth) /* add_send on <var_v:RapidTypeVisitor>*/;
3693 var8 = ((val* (*)(val*))(var_itmeth->class->vft[COLOR_model__MProperty__intro]))(var_itmeth) /* intro on <var_itmeth:MMethod>*/;
3694 var9 = ((val* (*)(val*))(var8->class->vft[COLOR_model__MMethodDef__msignature]))(var8) /* msignature on <var8:MPropDef(MMethodDef)>*/;
3695 if (var9 == NULL) {
3696 fprintf(stderr, "Runtime error: %s", "Receiver is null");
3697 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 612);
3698 show_backtrace(1);
3699 } else {
3700 var10 = ((val* (*)(val*))(var9->class->vft[COLOR_model__MSignature__return_mtype]))(var9) /* return_mtype on <var9:nullable MSignature>*/;
3701 }
3702 /* <var10:nullable MType> isa MClassType */
3703 cltype = type_model__MClassType.color;
3704 idtype = type_model__MClassType.id;
3705 if(var10 == NULL) {
3706 var11 = 0;
3707 } else {
3708 if(cltype >= var10->type->table_size) {
3709 var11 = 0;
3710 } else {
3711 var11 = var10->type->type_table[cltype] == idtype;
3712 }
3713 }
3714 if (!var11) {
3715 var_class_name = var10 == NULL ? "null" : var10->type->name;
3716 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
3717 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 612);
3718 show_backtrace(1);
3719 }
3720 var12 = ((val* (*)(val*))(var10->class->vft[COLOR_model__MClassType__mclass]))(var10) /* mclass on <var10:nullable MType(MClassType)>*/;
3721 var13 = ((val* (*)(val*))(var12->class->vft[COLOR_model__MClass__intro]))(var12) /* intro on <var12:MClass>*/;
3722 var14 = ((val* (*)(val*))(var13->class->vft[COLOR_model__MClassDef__bound_mtype]))(var13) /* bound_mtype on <var13:MClassDef>*/;
3723 var_iteratortype = var14;
3724 if (varonce15) {
3725 var16 = varonce15;
3726 } else {
3727 var17 = "Object";
3728 var18 = 6;
3729 var19 = string__NativeString__to_s_with_length(var17, var18);
3730 var16 = var19;
3731 varonce15 = var16;
3732 }
3733 var20 = ((val* (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__get_class]))(var_v, var16) /* get_class on <var_v:RapidTypeVisitor>*/;
3734 var21 = ((val* (*)(val*))(var20->class->vft[COLOR_model__MClass__mclass_type]))(var20) /* mclass_type on <var20:MClass>*/;
3735 var_objtype = var21;
3736 if (varonce22) {
3737 var23 = varonce22;
3738 } else {
3739 var24 = "is_ok";
3740 var25 = 5;
3741 var26 = string__NativeString__to_s_with_length(var24, var25);
3742 var23 = var26;
3743 varonce22 = var23;
3744 }
3745 var27 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__get_method]))(var_v, var_iteratortype, var23) /* get_method on <var_v:RapidTypeVisitor>*/;
3746 ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_send]))(var_v, var_objtype, var27) /* add_send on <var_v:RapidTypeVisitor>*/;
3747 var28 = ((val* (*)(val*))(self->class->vft[COLOR_scope__AForExpr__variables]))(self) /* variables on <self:AForExpr>*/;
3748 if (var28 == NULL) {
3749 fprintf(stderr, "Runtime error: %s", "Receiver is null");
3750 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 615);
3751 show_backtrace(1);
3752 } else {
3753 var29 = ((long (*)(val*))(var28->class->vft[COLOR_abstract_collection__Collection__length]))(var28) /* length on <var28:nullable Array[Variable]>*/;
3754 }
3755 var30 = 1;
3756 { /* Inline kernel#Int#== (var29,var30) */
3757 var33 = var29 == var30;
3758 var31 = var33;
3759 goto RET_LABEL32;
3760 RET_LABEL32:(void)0;
3761 }
3762 if (var31){
3763 if (varonce34) {
3764 var35 = varonce34;
3765 } else {
3766 var36 = "item";
3767 var37 = 4;
3768 var38 = string__NativeString__to_s_with_length(var36, var37);
3769 var35 = var38;
3770 varonce34 = var35;
3771 }
3772 var39 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__get_method]))(var_v, var_iteratortype, var35) /* get_method on <var_v:RapidTypeVisitor>*/;
3773 ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_send]))(var_v, var_objtype, var39) /* add_send on <var_v:RapidTypeVisitor>*/;
3774 } else {
3775 var40 = ((val* (*)(val*))(self->class->vft[COLOR_scope__AForExpr__variables]))(self) /* variables on <self:AForExpr>*/;
3776 if (var40 == NULL) {
3777 fprintf(stderr, "Runtime error: %s", "Receiver is null");
3778 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 617);
3779 show_backtrace(1);
3780 } else {
3781 var41 = ((long (*)(val*))(var40->class->vft[COLOR_abstract_collection__Collection__length]))(var40) /* length on <var40:nullable Array[Variable]>*/;
3782 }
3783 var42 = 2;
3784 { /* Inline kernel#Int#== (var41,var42) */
3785 var45 = var41 == var42;
3786 var43 = var45;
3787 goto RET_LABEL44;
3788 RET_LABEL44:(void)0;
3789 }
3790 if (var43){
3791 if (varonce46) {
3792 var47 = varonce46;
3793 } else {
3794 var48 = "key";
3795 var49 = 3;
3796 var50 = string__NativeString__to_s_with_length(var48, var49);
3797 var47 = var50;
3798 varonce46 = var47;
3799 }
3800 var51 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__get_method]))(var_v, var_iteratortype, var47) /* get_method on <var_v:RapidTypeVisitor>*/;
3801 ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_send]))(var_v, var_objtype, var51) /* add_send on <var_v:RapidTypeVisitor>*/;
3802 if (varonce52) {
3803 var53 = varonce52;
3804 } else {
3805 var54 = "item";
3806 var55 = 4;
3807 var56 = string__NativeString__to_s_with_length(var54, var55);
3808 var53 = var56;
3809 varonce52 = var53;
3810 }
3811 var57 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__get_method]))(var_v, var_iteratortype, var53) /* get_method on <var_v:RapidTypeVisitor>*/;
3812 ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_send]))(var_v, var_objtype, var57) /* add_send on <var_v:RapidTypeVisitor>*/;
3813 } else {
3814 fprintf(stderr, "Runtime error: %s", "Aborted");
3815 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 621);
3816 show_backtrace(1);
3817 }
3818 }
3819 if (varonce58) {
3820 var59 = varonce58;
3821 } else {
3822 var60 = "next";
3823 var61 = 4;
3824 var62 = string__NativeString__to_s_with_length(var60, var61);
3825 var59 = var62;
3826 varonce58 = var59;
3827 }
3828 var63 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__get_method]))(var_v, var_iteratortype, var59) /* get_method on <var_v:RapidTypeVisitor>*/;
3829 ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_send]))(var_v, var_objtype, var63) /* add_send on <var_v:RapidTypeVisitor>*/;
3830 RET_LABEL:;
3831 }
3832 /* method rapid_type_analysis#AForExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */
3833 void VIRTUAL_rapid_type_analysis__AForExpr__accept_rapid_type_visitor(val* self, val* p0) {
3834 rapid_type_analysis__AForExpr__accept_rapid_type_visitor(self, p0);
3835 RET_LABEL:;
3836 }
3837 /* method rapid_type_analysis#ANewExpr#accept_rapid_type_visitor for (self: ANewExpr, RapidTypeVisitor) */
3838 void rapid_type_analysis__ANewExpr__accept_rapid_type_visitor(val* self, val* p0) {
3839 val* var_v /* var v: RapidTypeVisitor */;
3840 val* var /* : nullable MType */;
3841 short int var1 /* : Bool */;
3842 int cltype;
3843 int idtype;
3844 const char* var_class_name;
3845 val* var_mtype /* var mtype: MClassType */;
3846 val* var2 /* : nullable CallSite */;
3847 var_v = p0;
3848 var = ((val* (*)(val*))(self->class->vft[COLOR_typing__AExpr__mtype]))(self) /* mtype on <self:ANewExpr>*/;
3849 /* <var:nullable MType> isa MClassType */
3850 cltype = type_model__MClassType.color;
3851 idtype = type_model__MClassType.id;
3852 if(var == NULL) {
3853 var1 = 0;
3854 } else {
3855 if(cltype >= var->type->table_size) {
3856 var1 = 0;
3857 } else {
3858 var1 = var->type->type_table[cltype] == idtype;
3859 }
3860 }
3861 if (!var1) {
3862 var_class_name = var == NULL ? "null" : var->type->name;
3863 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
3864 fprintf(stderr, " (%s:%d)\n", "src/rapid_type_analysis.nit", 630);
3865 show_backtrace(1);
3866 }
3867 var_mtype = var;
3868 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_type]))(var_v, var_mtype) /* add_type on <var_v:RapidTypeVisitor>*/;
3869 var2 = ((val* (*)(val*))(self->class->vft[COLOR_typing__ANewExpr__callsite]))(self) /* callsite on <self:ANewExpr>*/;
3870 ((void (*)(val*, val*))(var_v->class->vft[COLOR_rapid_type_analysis__RapidTypeVisitor__add_callsite]))(var_v, var2) /* add_callsite on <var_v:RapidTypeVisitor>*/;
3871 RET_LABEL:;
3872 }
3873 /* method rapid_type_analysis#ANewExpr#accept_rapid_type_visitor for (self: Object, RapidTypeVisitor) */
3874 void VIRTUAL_rapid_type_analysis__ANewExpr__accept_rapid_type_visitor(val* self, val* p0) {
3875 rapid_type_analysis__ANewExpr__accept_rapid_type_visitor(self, p0);
3876 RET_LABEL:;
3877 }