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