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