c_src/separate_erasure_compiler.sep.2.c

   1 #include "separate_erasure_compiler.sep.0.h"
   2 /* method separate_erasure_compiler#SeparateErasureCompilerVisitor#type_test for (self: SeparateErasureCompilerVisitor, RuntimeVariable, MType, String): RuntimeVariable */
   3 val* separate_erasure_compiler__SeparateErasureCompilerVisitor__type_test(val* self, val* p0, val* p1, val* p2) {
   4 val* var /* : RuntimeVariable */;
   5 val* var_value /* var value: RuntimeVariable */;
   6 val* var_mtype /* var mtype: MType */;
   7 val* var_tag /* var tag: String */;
   8 static val* varonce;
   9 val* var1 /* : String */;
  10 char* var2 /* : NativeString */;
  11 long var3 /* : Int */;
  12 val* var4 /* : FlatString */;
  13 val* var5 /* : String */;
  14 static val* varonce6;
  15 val* var7 /* : String */;
  16 char* var8 /* : NativeString */;
  17 long var9 /* : Int */;
  18 val* var10 /* : FlatString */;
  19 static val* varonce11;
  20 val* var12 /* : String */;
  21 char* var13 /* : NativeString */;
  22 long var14 /* : Int */;
  23 val* var15 /* : FlatString */;
  24 val* var16 /* : Array[Object] */;
  25 long var17 /* : Int */;
  26 val* var18 /* : NativeArray[Object] */;
  27 val* var19 /* : String */;
  28 val* var20 /* : MClassType */;
  29 val* var21 /* : RuntimeVariable */;
  30 val* var_res /* var res: RuntimeVariable */;
  31 static val* varonce22;
  32 val* var23 /* : String */;
  33 char* var24 /* : NativeString */;
  34 long var25 /* : Int */;
  35 val* var26 /* : FlatString */;
  36 val* var27 /* : String */;
  37 val* var_cltype /* var cltype: String */;
  38 static val* varonce28;
  39 val* var29 /* : String */;
  40 char* var30 /* : NativeString */;
  41 long var31 /* : Int */;
  42 val* var32 /* : FlatString */;
  43 static val* varonce33;
  44 val* var34 /* : String */;
  45 char* var35 /* : NativeString */;
  46 long var36 /* : Int */;
  47 val* var37 /* : FlatString */;
  48 val* var38 /* : Array[Object] */;
  49 long var39 /* : Int */;
  50 val* var40 /* : NativeArray[Object] */;
  51 val* var41 /* : String */;
  52 static val* varonce42;
  53 val* var43 /* : String */;
  54 char* var44 /* : NativeString */;
  55 long var45 /* : Int */;
  56 val* var46 /* : FlatString */;
  57 val* var47 /* : String */;
  58 val* var_idtype /* var idtype: String */;
  59 static val* varonce48;
  60 val* var49 /* : String */;
  61 char* var50 /* : NativeString */;
  62 long var51 /* : Int */;
  63 val* var52 /* : FlatString */;
  64 static val* varonce53;
  65 val* var54 /* : String */;
  66 char* var55 /* : NativeString */;
  67 long var56 /* : Int */;
  68 val* var57 /* : FlatString */;
  69 val* var58 /* : Array[Object] */;
  70 long var59 /* : Int */;
  71 val* var60 /* : NativeArray[Object] */;
  72 val* var61 /* : String */;
  73 short int var62 /* : Bool */;
  74 short int var_maybe_null /* var maybe_null: Bool */;
  75 static val* varonce63;
  76 val* var64 /* : String */;
  77 char* var65 /* : NativeString */;
  78 long var66 /* : Int */;
  79 val* var67 /* : FlatString */;
  80 val* var_accept_null /* var accept_null: String */;
  81 short int var68 /* : Bool */;
  82 int cltype;
  83 int idtype;
  84 val* var69 /* : MType */;
  85 val* var71 /* : MType */;
  86 static val* varonce72;
  87 val* var73 /* : String */;
  88 char* var74 /* : NativeString */;
  89 long var75 /* : Int */;
  90 val* var76 /* : FlatString */;
  91 short int var77 /* : Bool */;
  92 int cltype78;
  93 int idtype79;
  94 val* var80 /* : nullable Frame */;
  95 val* var82 /* : nullable Frame */;
  96 val* var83 /* : MPropDef */;
  97 val* var85 /* : MPropDef */;
  98 val* var86 /* : MClassDef */;
  99 val* var88 /* : MClassDef */;
 100 val* var89 /* : MClassType */;
 101 val* var91 /* : MClassType */;
 102 val* var92 /* : nullable Frame */;
 103 val* var94 /* : nullable Frame */;
 104 val* var95 /* : MPropDef */;
 105 val* var97 /* : MPropDef */;
 106 val* var98 /* : MClassDef */;
 107 val* var100 /* : MClassDef */;
 108 val* var101 /* : MClassType */;
 109 val* var103 /* : MClassType */;
 110 val* var104 /* : nullable Frame */;
 111 val* var106 /* : nullable Frame */;
 112 val* var107 /* : MPropDef */;
 113 val* var109 /* : MPropDef */;
 114 val* var110 /* : MClassDef */;
 115 val* var112 /* : MClassDef */;
 116 val* var113 /* : MModule */;
 117 val* var115 /* : MModule */;
 118 short int var116 /* : Bool */;
 119 val* var117 /* : MType */;
 120 short int var118 /* : Bool */;
 121 int cltype119;
 122 int idtype120;
 123 val* var121 /* : MType */;
 124 val* var123 /* : MType */;
 125 static val* varonce124;
 126 val* var125 /* : String */;
 127 char* var126 /* : NativeString */;
 128 long var127 /* : Int */;
 129 val* var128 /* : FlatString */;
 130 val* var129 /* : MType */;
 131 val* var131 /* : MType */;
 132 val* var132 /* : nullable Frame */;
 133 val* var134 /* : nullable Frame */;
 134 val* var135 /* : MPropDef */;
 135 val* var137 /* : MPropDef */;
 136 val* var138 /* : MClassDef */;
 137 val* var140 /* : MClassDef */;
 138 val* var141 /* : MModule */;
 139 val* var143 /* : MModule */;
 140 val* var144 /* : nullable Frame */;
 141 val* var146 /* : nullable Frame */;
 142 val* var147 /* : MPropDef */;
 143 val* var149 /* : MPropDef */;
 144 val* var150 /* : MClassDef */;
 145 val* var152 /* : MClassDef */;
 146 val* var153 /* : MClassType */;
 147 val* var155 /* : MClassType */;
 148 short int var156 /* : Bool */;
 149 static val* varonce157;
 150 val* var158 /* : String */;
 151 char* var159 /* : NativeString */;
 152 long var160 /* : Int */;
 153 val* var161 /* : FlatString */;
 154 val* var162 /* : String */;
 155 static val* varonce163;
 156 val* var164 /* : String */;
 157 char* var165 /* : NativeString */;
 158 long var166 /* : Int */;
 159 val* var167 /* : FlatString */;
 160 static val* varonce168;
 161 val* var169 /* : String */;
 162 char* var170 /* : NativeString */;
 163 long var171 /* : Int */;
 164 val* var172 /* : FlatString */;
 165 val* var173 /* : Array[Object] */;
 166 long var174 /* : Int */;
 167 val* var175 /* : NativeArray[Object] */;
 168 val* var176 /* : String */;
 169 val* var177 /* : AbstractCompiler */;
 170 val* var179 /* : AbstractCompiler */;
 171 val* var180 /* : ModelBuilder */;
 172 val* var182 /* : ModelBuilder */;
 173 val* var183 /* : ToolContext */;
 174 val* var185 /* : ToolContext */;
 175 val* var186 /* : OptionBool */;
 176 val* var188 /* : OptionBool */;
 177 val* var189 /* : nullable Object */;
 178 val* var191 /* : nullable Object */;
 179 short int var192 /* : Bool */;
 180 val* var193 /* : AbstractCompiler */;
 181 val* var195 /* : AbstractCompiler */;
 182 val* var196 /* : HashMap[String, Int] */;
 183 val* var198 /* : HashMap[String, Int] */;
 184 val* var_ /* var : HashMap[String, Int] */;
 185 val* var_199 /* var : String */;
 186 val* var200 /* : nullable Object */;
 187 long var201 /* : Int */;
 188 long var202 /* : Int */;
 189 short int var204 /* : Bool */;
 190 int cltype205;
 191 int idtype206;
 192 const char* var_class_name;
 193 long var207 /* : Int */;
 194 long var208 /* : Int */;
 195 val* var209 /* : nullable Object */;
 196 static val* varonce210;
 197 val* var211 /* : String */;
 198 char* var212 /* : NativeString */;
 199 long var213 /* : Int */;
 200 val* var214 /* : FlatString */;
 201 static val* varonce215;
 202 val* var216 /* : String */;
 203 char* var217 /* : NativeString */;
 204 long var218 /* : Int */;
 205 val* var219 /* : FlatString */;
 206 val* var220 /* : Array[Object] */;
 207 long var221 /* : Int */;
 208 val* var222 /* : NativeArray[Object] */;
 209 val* var223 /* : String */;
 210 val* var224 /* : MType */;
 211 val* var226 /* : MType */;
 212 val* var227 /* : String */;
 213 static val* varonce228;
 214 val* var229 /* : String */;
 215 char* var230 /* : NativeString */;
 216 long var231 /* : Int */;
 217 val* var232 /* : FlatString */;
 218 short int var233 /* : Bool */;
 219 short int var234 /* : Bool */;
 220 static val* varonce235;
 221 val* var236 /* : String */;
 222 char* var237 /* : NativeString */;
 223 long var238 /* : Int */;
 224 val* var239 /* : FlatString */;
 225 val* var240 /* : Array[Object] */;
 226 long var241 /* : Int */;
 227 val* var242 /* : NativeArray[Object] */;
 228 val* var243 /* : String */;
 229 val* var_class_ptr /* var class_ptr: nullable Object */;
 230 val* var244 /* : MType */;
 231 val* var246 /* : MType */;
 232 short int var247 /* : Bool */;
 233 int cltype248;
 234 int idtype249;
 235 const char* var_class_name250;
 236 val* var251 /* : MClass */;
 237 val* var253 /* : MClass */;
 238 val* var_mclass /* var mclass: MClass */;
 239 static val* varonce254;
 240 val* var255 /* : String */;
 241 char* var256 /* : NativeString */;
 242 long var257 /* : Int */;
 243 val* var258 /* : FlatString */;
 244 val* var259 /* : String */;
 245 val* var260 /* : Array[Object] */;
 246 long var261 /* : Int */;
 247 val* var262 /* : NativeArray[Object] */;
 248 val* var263 /* : String */;
 249 static val* varonce264;
 250 val* var265 /* : String */;
 251 char* var266 /* : NativeString */;
 252 long var267 /* : Int */;
 253 val* var268 /* : FlatString */;
 254 val* var269 /* : String */;
 255 static val* varonce270;
 256 val* var271 /* : String */;
 257 char* var272 /* : NativeString */;
 258 long var273 /* : Int */;
 259 val* var274 /* : FlatString */;
 260 val* var275 /* : Array[Object] */;
 261 long var276 /* : Int */;
 262 val* var277 /* : NativeArray[Object] */;
 263 val* var278 /* : String */;
 264 short int var279 /* : Bool */;
 265 int cltype280;
 266 int idtype281;
 267 static val* varonce282;
 268 val* var283 /* : String */;
 269 char* var284 /* : NativeString */;
 270 long var285 /* : Int */;
 271 val* var286 /* : FlatString */;
 272 val* var287 /* : MClass */;
 273 val* var289 /* : MClass */;
 274 val* var290 /* : String */;
 275 val* var291 /* : Array[Object] */;
 276 long var292 /* : Int */;
 277 val* var293 /* : NativeArray[Object] */;
 278 val* var294 /* : String */;
 279 static val* varonce295;
 280 val* var296 /* : String */;
 281 char* var297 /* : NativeString */;
 282 long var298 /* : Int */;
 283 val* var299 /* : FlatString */;
 284 val* var300 /* : MClass */;
 285 val* var302 /* : MClass */;
 286 val* var303 /* : String */;
 287 static val* varonce304;
 288 val* var305 /* : String */;
 289 char* var306 /* : NativeString */;
 290 long var307 /* : Int */;
 291 val* var308 /* : FlatString */;
 292 val* var309 /* : Array[Object] */;
 293 long var310 /* : Int */;
 294 val* var311 /* : NativeArray[Object] */;
 295 val* var312 /* : String */;
 296 static val* varonce313;
 297 val* var314 /* : String */;
 298 char* var315 /* : NativeString */;
 299 long var316 /* : Int */;
 300 val* var317 /* : FlatString */;
 301 val* var318 /* : MClass */;
 302 val* var320 /* : MClass */;
 303 val* var321 /* : String */;
 304 static val* varonce322;
 305 val* var323 /* : String */;
 306 char* var324 /* : NativeString */;
 307 long var325 /* : Int */;
 308 val* var326 /* : FlatString */;
 309 val* var327 /* : Array[Object] */;
 310 long var328 /* : Int */;
 311 val* var329 /* : NativeArray[Object] */;
 312 val* var330 /* : String */;
 313 val* var331 /* : AbstractCompiler */;
 314 val* var333 /* : AbstractCompiler */;
 315 val* var334 /* : ModelBuilder */;
 316 val* var336 /* : ModelBuilder */;
 317 val* var337 /* : ToolContext */;
 318 val* var339 /* : ToolContext */;
 319 val* var340 /* : OptionBool */;
 320 val* var342 /* : OptionBool */;
 321 val* var343 /* : nullable Object */;
 322 val* var345 /* : nullable Object */;
 323 short int var346 /* : Bool */;
 324 val* var347 /* : AbstractCompiler */;
 325 val* var349 /* : AbstractCompiler */;
 326 val* var350 /* : HashMap[String, Int] */;
 327 val* var352 /* : HashMap[String, Int] */;
 328 val* var_353 /* var : HashMap[String, Int] */;
 329 val* var_354 /* var : String */;
 330 val* var355 /* : nullable Object */;
 331 long var356 /* : Int */;
 332 long var357 /* : Int */;
 333 short int var359 /* : Bool */;
 334 int cltype360;
 335 int idtype361;
 336 const char* var_class_name362;
 337 long var363 /* : Int */;
 338 long var364 /* : Int */;
 339 val* var365 /* : nullable Object */;
 340 static val* varonce366;
 341 val* var367 /* : String */;
 342 char* var368 /* : NativeString */;
 343 long var369 /* : Int */;
 344 val* var370 /* : FlatString */;
 345 static val* varonce371;
 346 val* var372 /* : String */;
 347 char* var373 /* : NativeString */;
 348 long var374 /* : Int */;
 349 val* var375 /* : FlatString */;
 350 val* var376 /* : Array[Object] */;
 351 long var377 /* : Int */;
 352 val* var378 /* : NativeArray[Object] */;
 353 val* var379 /* : String */;
 354 short int var380 /* : Bool */;
 355 int cltype381;
 356 int idtype382;
 357 val* var383 /* : nullable Frame */;
 358 val* var385 /* : nullable Frame */;
 359 val* var386 /* : Array[RuntimeVariable] */;
 360 val* var388 /* : Array[RuntimeVariable] */;
 361 val* var389 /* : nullable Object */;
 362 val* var_recv /* var recv: RuntimeVariable */;
 363 val* var390 /* : MType */;
 364 val* var392 /* : MType */;
 365 val* var393 /* : String */;
 366 static val* varonce394;
 367 val* var395 /* : String */;
 368 char* var396 /* : NativeString */;
 369 long var397 /* : Int */;
 370 val* var398 /* : FlatString */;
 371 short int var399 /* : Bool */;
 372 short int var400 /* : Bool */;
 373 static val* varonce401;
 374 val* var402 /* : String */;
 375 char* var403 /* : NativeString */;
 376 long var404 /* : Int */;
 377 val* var405 /* : FlatString */;
 378 val* var406 /* : Array[Object] */;
 379 long var407 /* : Int */;
 380 val* var408 /* : NativeArray[Object] */;
 381 val* var409 /* : String */;
 382 val* var_recv_ptr /* var recv_ptr: nullable Object */;
 383 val* var410 /* : MType */;
 384 val* var412 /* : MType */;
 385 short int var413 /* : Bool */;
 386 int cltype414;
 387 int idtype415;
 388 const char* var_class_name416;
 389 val* var417 /* : MClass */;
 390 val* var419 /* : MClass */;
 391 val* var_mclass420 /* var mclass: MClass */;
 392 static val* varonce421;
 393 val* var422 /* : String */;
 394 char* var423 /* : NativeString */;
 395 long var424 /* : Int */;
 396 val* var425 /* : FlatString */;
 397 val* var426 /* : String */;
 398 val* var427 /* : Array[Object] */;
 399 long var428 /* : Int */;
 400 val* var429 /* : NativeArray[Object] */;
 401 val* var430 /* : String */;
 402 static val* varonce431;
 403 val* var432 /* : String */;
 404 char* var433 /* : NativeString */;
 405 long var434 /* : Int */;
 406 val* var435 /* : FlatString */;
 407 val* var436 /* : String */;
 408 static val* varonce437;
 409 val* var438 /* : String */;
 410 char* var439 /* : NativeString */;
 411 long var440 /* : Int */;
 412 val* var441 /* : FlatString */;
 413 val* var442 /* : Array[Object] */;
 414 long var443 /* : Int */;
 415 val* var444 /* : NativeArray[Object] */;
 416 val* var445 /* : String */;
 417 static val* varonce446;
 418 val* var447 /* : String */;
 419 char* var448 /* : NativeString */;
 420 long var449 /* : Int */;
 421 val* var450 /* : FlatString */;
 422 val* var451 /* : String */;
 423 val* var_entry /* var entry: String */;
 424 static val* varonce452;
 425 val* var453 /* : String */;
 426 char* var454 /* : NativeString */;
 427 long var455 /* : Int */;
 428 val* var456 /* : FlatString */;
 429 static val* varonce457;
 430 val* var458 /* : String */;
 431 char* var459 /* : NativeString */;
 432 long var460 /* : Int */;
 433 val* var461 /* : FlatString */;
 434 val* var462 /* : Array[Object] */;
 435 long var463 /* : Int */;
 436 val* var464 /* : NativeArray[Object] */;
 437 val* var465 /* : String */;
 438 val* var466 /* : MProperty */;
 439 val* var468 /* : MProperty */;
 440 val* var469 /* : String */;
 441 static val* varonce470;
 442 val* var471 /* : String */;
 443 char* var472 /* : NativeString */;
 444 long var473 /* : Int */;
 445 val* var474 /* : FlatString */;
 446 static val* varonce475;
 447 val* var476 /* : String */;
 448 char* var477 /* : NativeString */;
 449 long var478 /* : Int */;
 450 val* var479 /* : FlatString */;
 451 val* var480 /* : MProperty */;
 452 val* var482 /* : MProperty */;
 453 val* var483 /* : String */;
 454 static val* varonce484;
 455 val* var485 /* : String */;
 456 char* var486 /* : NativeString */;
 457 long var487 /* : Int */;
 458 val* var488 /* : FlatString */;
 459 val* var489 /* : Array[Object] */;
 460 long var490 /* : Int */;
 461 val* var491 /* : NativeArray[Object] */;
 462 val* var492 /* : String */;
 463 static val* varonce493;
 464 val* var494 /* : String */;
 465 char* var495 /* : NativeString */;
 466 long var496 /* : Int */;
 467 val* var497 /* : FlatString */;
 468 static val* varonce498;
 469 val* var499 /* : String */;
 470 char* var500 /* : NativeString */;
 471 long var501 /* : Int */;
 472 val* var502 /* : FlatString */;
 473 val* var503 /* : Array[Object] */;
 474 long var504 /* : Int */;
 475 val* var505 /* : NativeArray[Object] */;
 476 val* var506 /* : String */;
 477 static val* varonce507;
 478 val* var508 /* : String */;
 479 char* var509 /* : NativeString */;
 480 long var510 /* : Int */;
 481 val* var511 /* : FlatString */;
 482 static val* varonce512;
 483 val* var513 /* : String */;
 484 char* var514 /* : NativeString */;
 485 long var515 /* : Int */;
 486 val* var516 /* : FlatString */;
 487 val* var517 /* : Array[Object] */;
 488 long var518 /* : Int */;
 489 val* var519 /* : NativeArray[Object] */;
 490 val* var520 /* : String */;
 491 short int var521 /* : Bool */;
 492 short int var_522 /* var : Bool */;
 493 static val* varonce523;
 494 val* var524 /* : String */;
 495 char* var525 /* : NativeString */;
 496 long var526 /* : Int */;
 497 val* var527 /* : FlatString */;
 498 short int var528 /* : Bool */;
 499 short int var529 /* : Bool */;
 500 static val* varonce530;
 501 val* var531 /* : String */;
 502 char* var532 /* : NativeString */;
 503 long var533 /* : Int */;
 504 val* var534 /* : FlatString */;
 505 val* var535 /* : String */;
 506 val* var_is_nullable /* var is_nullable: String */;
 507 static val* varonce536;
 508 val* var537 /* : String */;
 509 char* var538 /* : NativeString */;
 510 long var539 /* : Int */;
 511 val* var540 /* : FlatString */;
 512 static val* varonce541;
 513 val* var542 /* : String */;
 514 char* var543 /* : NativeString */;
 515 long var544 /* : Int */;
 516 val* var545 /* : FlatString */;
 517 val* var546 /* : Array[Object] */;
 518 long var547 /* : Int */;
 519 val* var548 /* : NativeArray[Object] */;
 520 val* var549 /* : String */;
 521 static val* varonce550;
 522 val* var551 /* : String */;
 523 char* var552 /* : NativeString */;
 524 long var553 /* : Int */;
 525 val* var554 /* : FlatString */;
 526 static val* varonce555;
 527 val* var556 /* : String */;
 528 char* var557 /* : NativeString */;
 529 long var558 /* : Int */;
 530 val* var559 /* : FlatString */;
 531 val* var560 /* : Array[Object] */;
 532 long var561 /* : Int */;
 533 val* var562 /* : NativeArray[Object] */;
 534 val* var563 /* : String */;
 535 val* var564 /* : String */;
 536 val* var565 /* : AbstractCompiler */;
 537 val* var567 /* : AbstractCompiler */;
 538 val* var568 /* : ModelBuilder */;
 539 val* var570 /* : ModelBuilder */;
 540 val* var571 /* : ToolContext */;
 541 val* var573 /* : ToolContext */;
 542 val* var574 /* : OptionBool */;
 543 val* var576 /* : OptionBool */;
 544 val* var577 /* : nullable Object */;
 545 val* var579 /* : nullable Object */;
 546 short int var580 /* : Bool */;
 547 val* var581 /* : AbstractCompiler */;
 548 val* var583 /* : AbstractCompiler */;
 549 val* var584 /* : HashMap[String, Int] */;
 550 val* var586 /* : HashMap[String, Int] */;
 551 val* var_587 /* var : HashMap[String, Int] */;
 552 val* var_588 /* var : String */;
 553 val* var589 /* : nullable Object */;
 554 long var590 /* : Int */;
 555 long var591 /* : Int */;
 556 short int var593 /* : Bool */;
 557 int cltype594;
 558 int idtype595;
 559 const char* var_class_name596;
 560 long var597 /* : Int */;
 561 long var598 /* : Int */;
 562 val* var599 /* : nullable Object */;
 563 static val* varonce600;
 564 val* var601 /* : String */;
 565 char* var602 /* : NativeString */;
 566 long var603 /* : Int */;
 567 val* var604 /* : FlatString */;
 568 static val* varonce605;
 569 val* var606 /* : String */;
 570 char* var607 /* : NativeString */;
 571 long var608 /* : Int */;
 572 val* var609 /* : FlatString */;
 573 val* var610 /* : Array[Object] */;
 574 long var611 /* : Int */;
 575 val* var612 /* : NativeArray[Object] */;
 576 val* var613 /* : String */;
 577 static val* varonce614;
 578 val* var615 /* : String */;
 579 char* var616 /* : NativeString */;
 580 long var617 /* : Int */;
 581 val* var618 /* : FlatString */;
 582 val* var619 /* : String */;
 583 static val* varonce620;
 584 val* var621 /* : String */;
 585 char* var622 /* : NativeString */;
 586 long var623 /* : Int */;
 587 val* var624 /* : FlatString */;
 588 static val* varonce625;
 589 val* var626 /* : String */;
 590 char* var627 /* : NativeString */;
 591 long var628 /* : Int */;
 592 val* var629 /* : FlatString */;
 593 val* var630 /* : Array[Object] */;
 594 long var631 /* : Int */;
 595 val* var632 /* : NativeArray[Object] */;
 596 val* var633 /* : String */;
 597 static val* varonce634;
 598 val* var635 /* : String */;
 599 char* var636 /* : NativeString */;
 600 long var637 /* : Int */;
 601 val* var638 /* : FlatString */;
 602 static val* varonce639;
 603 val* var640 /* : String */;
 604 char* var641 /* : NativeString */;
 605 long var642 /* : Int */;
 606 val* var643 /* : FlatString */;
 607 val* var644 /* : Array[Object] */;
 608 long var645 /* : Int */;
 609 val* var646 /* : NativeArray[Object] */;
 610 val* var647 /* : String */;
 611 static val* varonce648;
 612 val* var649 /* : String */;
 613 char* var650 /* : NativeString */;
 614 long var651 /* : Int */;
 615 val* var652 /* : FlatString */;
 616 static val* varonce653;
 617 val* var654 /* : String */;
 618 char* var655 /* : NativeString */;
 619 long var656 /* : Int */;
 620 val* var657 /* : FlatString */;
 621 val* var658 /* : Array[Object] */;
 622 long var659 /* : Int */;
 623 val* var660 /* : NativeArray[Object] */;
 624 val* var661 /* : String */;
 625 static val* varonce662;
 626 val* var663 /* : String */;
 627 char* var664 /* : NativeString */;
 628 long var665 /* : Int */;
 629 val* var666 /* : FlatString */;
 630 static val* varonce667;
 631 val* var668 /* : String */;
 632 char* var669 /* : NativeString */;
 633 long var670 /* : Int */;
 634 val* var671 /* : FlatString */;
 635 static val* varonce672;
 636 val* var673 /* : String */;
 637 char* var674 /* : NativeString */;
 638 long var675 /* : Int */;
 639 val* var676 /* : FlatString */;
 640 static val* varonce677;
 641 val* var678 /* : String */;
 642 char* var679 /* : NativeString */;
 643 long var680 /* : Int */;
 644 val* var681 /* : FlatString */;
 645 val* var682 /* : Array[Object] */;
 646 long var683 /* : Int */;
 647 val* var684 /* : NativeArray[Object] */;
 648 val* var685 /* : String */;
 649 static val* varonce686;
 650 val* var687 /* : String */;
 651 char* var688 /* : NativeString */;
 652 long var689 /* : Int */;
 653 val* var690 /* : FlatString */;
 654 val* var691 /* : Array[Object] */;
 655 long var692 /* : Int */;
 656 val* var693 /* : NativeArray[Object] */;
 657 val* var694 /* : String */;
 658 static val* varonce695;
 659 val* var696 /* : String */;
 660 char* var697 /* : NativeString */;
 661 long var698 /* : Int */;
 662 val* var699 /* : FlatString */;
 663 static val* varonce700;
 664 val* var701 /* : String */;
 665 char* var702 /* : NativeString */;
 666 long var703 /* : Int */;
 667 val* var704 /* : FlatString */;
 668 static val* varonce705;
 669 val* var706 /* : String */;
 670 char* var707 /* : NativeString */;
 671 long var708 /* : Int */;
 672 val* var709 /* : FlatString */;
 673 static val* varonce710;
 674 val* var711 /* : String */;
 675 char* var712 /* : NativeString */;
 676 long var713 /* : Int */;
 677 val* var714 /* : FlatString */;
 678 static val* varonce715;
 679 val* var716 /* : String */;
 680 char* var717 /* : NativeString */;
 681 long var718 /* : Int */;
 682 val* var719 /* : FlatString */;
 683 val* var720 /* : Array[Object] */;
 684 long var721 /* : Int */;
 685 val* var722 /* : NativeArray[Object] */;
 686 val* var723 /* : String */;
 687 static val* varonce724;
 688 val* var725 /* : String */;
 689 char* var726 /* : NativeString */;
 690 long var727 /* : Int */;
 691 val* var728 /* : FlatString */;
 692 static val* varonce729;
 693 val* var730 /* : String */;
 694 char* var731 /* : NativeString */;
 695 long var732 /* : Int */;
 696 val* var733 /* : FlatString */;
 697 var_value = p0;
 698 var_mtype = p1;
 699 var_tag = p2;
 700 if (varonce) {
 701 var1 = varonce;
 702 } else {
 703 var2 = "/* type test for ";
 704 var3 = 17;
 705 var4 = string__NativeString__to_s_with_length(var2, var3);
 706 var1 = var4;
 707 varonce = var1;
 708 }
 709 {
 710 var5 = abstract_compiler__RuntimeVariable__inspect(var_value);
 711 }
 712 if (varonce6) {
 713 var7 = varonce6;
 714 } else {
 715 var8 = " isa ";
 716 var9 = 5;
 717 var10 = string__NativeString__to_s_with_length(var8, var9);
 718 var7 = var10;
 719 varonce6 = var7;
 720 }
 721 if (varonce11) {
 722 var12 = varonce11;
 723 } else {
 724 var13 = " */";
 725 var14 = 3;
 726 var15 = string__NativeString__to_s_with_length(var13, var14);
 727 var12 = var15;
 728 varonce11 = var12;
 729 }
 730 var16 = NEW_array__Array(&type_array__Arraykernel__Object);
 731 { /* var16 = array_instance Array[Object] */
 732 var17 = 5;
 733 var18 = NEW_array__NativeArray(var17, &type_array__NativeArraykernel__Object);
 734 ((struct instance_array__NativeArray*)var18)->values[0] = (val*) var1;
 735 ((struct instance_array__NativeArray*)var18)->values[1] = (val*) var5;
 736 ((struct instance_array__NativeArray*)var18)->values[2] = (val*) var7;
 737 ((struct instance_array__NativeArray*)var18)->values[3] = (val*) var_mtype;
 738 ((struct instance_array__NativeArray*)var18)->values[4] = (val*) var12;
 739 {
 740 ((void (*)(val*, val*, long))(var16->class->vft[COLOR_array__Array__with_native]))(var16, var18, var17) /* with_native on <var16:Array[Object]>*/;
 741 }
 742 }
 743 {
 744 var19 = ((val* (*)(val*))(var16->class->vft[COLOR_string__Object__to_s]))(var16) /* to_s on <var16:Array[Object]>*/;
 745 }
 746 {
 747 abstract_compiler__AbstractCompilerVisitor__add(self, var19); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
 748 }
 749 {
 750 var20 = abstract_compiler__AbstractCompilerVisitor__bool_type(self);
 751 }
 752 {
 753 var21 = abstract_compiler__AbstractCompilerVisitor__new_var(self, var20);
 754 }
 755 var_res = var21;
 756 if (varonce22) {
 757 var23 = varonce22;
 758 } else {
 759 var24 = "cltype";
 760 var25 = 6;
 761 var26 = string__NativeString__to_s_with_length(var24, var25);
 762 var23 = var26;
 763 varonce22 = var23;
 764 }
 765 {
 766 var27 = abstract_compiler__AbstractCompilerVisitor__get_name(self, var23);
 767 }
 768 var_cltype = var27;
 769 if (varonce28) {
 770 var29 = varonce28;
 771 } else {
 772 var30 = "int ";
 773 var31 = 4;
 774 var32 = string__NativeString__to_s_with_length(var30, var31);
 775 var29 = var32;
 776 varonce28 = var29;
 777 }
 778 if (varonce33) {
 779 var34 = varonce33;
 780 } else {
 781 var35 = ";";
 782 var36 = 1;
 783 var37 = string__NativeString__to_s_with_length(var35, var36);
 784 var34 = var37;
 785 varonce33 = var34;
 786 }
 787 var38 = NEW_array__Array(&type_array__Arraykernel__Object);
 788 { /* var38 = array_instance Array[Object] */
 789 var39 = 3;
 790 var40 = NEW_array__NativeArray(var39, &type_array__NativeArraykernel__Object);
 791 ((struct instance_array__NativeArray*)var40)->values[0] = (val*) var29;
 792 ((struct instance_array__NativeArray*)var40)->values[1] = (val*) var_cltype;
 793 ((struct instance_array__NativeArray*)var40)->values[2] = (val*) var34;
 794 {
 795 ((void (*)(val*, val*, long))(var38->class->vft[COLOR_array__Array__with_native]))(var38, var40, var39) /* with_native on <var38:Array[Object]>*/;
 796 }
 797 }
 798 {
 799 var41 = ((val* (*)(val*))(var38->class->vft[COLOR_string__Object__to_s]))(var38) /* to_s on <var38:Array[Object]>*/;
 800 }
 801 {
 802 abstract_compiler__AbstractCompilerVisitor__add_decl(self, var41); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on <self:SeparateErasureCompilerVisitor>*/
 803 }
 804 if (varonce42) {
 805 var43 = varonce42;
 806 } else {
 807 var44 = "idtype";
 808 var45 = 6;
 809 var46 = string__NativeString__to_s_with_length(var44, var45);
 810 var43 = var46;
 811 varonce42 = var43;
 812 }
 813 {
 814 var47 = abstract_compiler__AbstractCompilerVisitor__get_name(self, var43);
 815 }
 816 var_idtype = var47;
 817 if (varonce48) {
 818 var49 = varonce48;
 819 } else {
 820 var50 = "int ";
 821 var51 = 4;
 822 var52 = string__NativeString__to_s_with_length(var50, var51);
 823 var49 = var52;
 824 varonce48 = var49;
 825 }
 826 if (varonce53) {
 827 var54 = varonce53;
 828 } else {
 829 var55 = ";";
 830 var56 = 1;
 831 var57 = string__NativeString__to_s_with_length(var55, var56);
 832 var54 = var57;
 833 varonce53 = var54;
 834 }
 835 var58 = NEW_array__Array(&type_array__Arraykernel__Object);
 836 { /* var58 = array_instance Array[Object] */
 837 var59 = 3;
 838 var60 = NEW_array__NativeArray(var59, &type_array__NativeArraykernel__Object);
 839 ((struct instance_array__NativeArray*)var60)->values[0] = (val*) var49;
 840 ((struct instance_array__NativeArray*)var60)->values[1] = (val*) var_idtype;
 841 ((struct instance_array__NativeArray*)var60)->values[2] = (val*) var54;
 842 {
 843 ((void (*)(val*, val*, long))(var58->class->vft[COLOR_array__Array__with_native]))(var58, var60, var59) /* with_native on <var58:Array[Object]>*/;
 844 }
 845 }
 846 {
 847 var61 = ((val* (*)(val*))(var58->class->vft[COLOR_string__Object__to_s]))(var58) /* to_s on <var58:Array[Object]>*/;
 848 }
 849 {
 850 abstract_compiler__AbstractCompilerVisitor__add_decl(self, var61); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on <self:SeparateErasureCompilerVisitor>*/
 851 }
 852 {
 853 var62 = separate_compiler__SeparateCompilerVisitor__maybe_null(self, var_value);
 854 }
 855 var_maybe_null = var62;
 856 if (varonce63) {
 857 var64 = varonce63;
 858 } else {
 859 var65 = "0";
 860 var66 = 1;
 861 var67 = string__NativeString__to_s_with_length(var65, var66);
 862 var64 = var67;
 863 varonce63 = var64;
 864 }
 865 var_accept_null = var64;
 866 /* <var_mtype:MType> isa MNullableType */
 867 cltype = type_model__MNullableType.color;
 868 idtype = type_model__MNullableType.id;
 869 if(cltype >= var_mtype->type->table_size) {
 870 var68 = 0;
 871 } else {
 872 var68 = var_mtype->type->type_table[cltype] == idtype;
 873 }
 874 if (var68){
 875 {
 876 { /* Inline model#MNullableType#mtype (var_mtype) on <var_mtype:MType(MNullableType)> */
 877 var71 = var_mtype->attrs[COLOR_model__MNullableType___mtype].val; /* _mtype on <var_mtype:MType(MNullableType)> */
 878 if (unlikely(var71 == NULL)) {
 879 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype");
 880 PRINT_ERROR(" (%s:%d)\n", "src/model/model.nit", 1375);
 881 show_backtrace(1);
 882 }
 883 var69 = var71;
 884 RET_LABEL70:(void)0;
 885 }
 886 }
 887 var_mtype = var69;
 888 if (varonce72) {
 889 var73 = varonce72;
 890 } else {
 891 var74 = "1";
 892 var75 = 1;
 893 var76 = string__NativeString__to_s_with_length(var74, var75);
 894 var73 = var76;
 895 varonce72 = var73;
 896 }
 897 var_accept_null = var73;
 898 } else {
 899 }
 900 /* <var_mtype:MType> isa MParameterType */
 901 cltype78 = type_model__MParameterType.color;
 902 idtype79 = type_model__MParameterType.id;
 903 if(cltype78 >= var_mtype->type->table_size) {
 904 var77 = 0;
 905 } else {
 906 var77 = var_mtype->type->type_table[cltype78] == idtype79;
 907 }
 908 if (var77){
 909 {
 910 { /* Inline abstract_compiler#AbstractCompilerVisitor#frame (self) on <self:SeparateErasureCompilerVisitor> */
 911 var82 = self->attrs[COLOR_abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on <self:SeparateErasureCompilerVisitor> */
 912 var80 = var82;
 913 RET_LABEL81:(void)0;
 914 }
 915 }
 916 if (var80 == NULL) {
 917 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 918 PRINT_ERROR(" (%s:%d)\n", "src/separate_erasure_compiler.nit", 489);
 919 show_backtrace(1);
 920 } else {
 921 { /* Inline abstract_compiler#Frame#mpropdef (var80) on <var80:nullable Frame> */
 922 if (unlikely(var80 == NULL)) {
 923 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 924 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 1531);
 925 show_backtrace(1);
 926 }
 927 var85 = var80->attrs[COLOR_abstract_compiler__Frame___mpropdef].val; /* _mpropdef on <var80:nullable Frame> */
 928 if (unlikely(var85 == NULL)) {
 929 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdef");
 930 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 1531);
 931 show_backtrace(1);
 932 }
 933 var83 = var85;
 934 RET_LABEL84:(void)0;
 935 }
 936 }
 937 {
 938 { /* Inline model#MPropDef#mclassdef (var83) on <var83:MPropDef> */
 939 var88 = var83->attrs[COLOR_model__MPropDef___mclassdef].val; /* _mclassdef on <var83:MPropDef> */
 940 if (unlikely(var88 == NULL)) {
 941 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef");
 942 PRINT_ERROR(" (%s:%d)\n", "src/model/model.nit", 1879);
 943 show_backtrace(1);
 944 }
 945 var86 = var88;
 946 RET_LABEL87:(void)0;
 947 }
 948 }
 949 {
 950 { /* Inline model#MClassDef#bound_mtype (var86) on <var86:MClassDef> */
 951 var91 = var86->attrs[COLOR_model__MClassDef___bound_mtype].val; /* _bound_mtype on <var86:MClassDef> */
 952 if (unlikely(var91 == NULL)) {
 953 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype");
 954 PRINT_ERROR(" (%s:%d)\n", "src/model/model.nit", 477);
 955 show_backtrace(1);
 956 }
 957 var89 = var91;
 958 RET_LABEL90:(void)0;
 959 }
 960 }
 961 {
 962 { /* Inline abstract_compiler#AbstractCompilerVisitor#frame (self) on <self:SeparateErasureCompilerVisitor> */
 963 var94 = self->attrs[COLOR_abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on <self:SeparateErasureCompilerVisitor> */
 964 var92 = var94;
 965 RET_LABEL93:(void)0;
 966 }
 967 }
 968 if (var92 == NULL) {
 969 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 970 PRINT_ERROR(" (%s:%d)\n", "src/separate_erasure_compiler.nit", 489);
 971 show_backtrace(1);
 972 } else {
 973 { /* Inline abstract_compiler#Frame#mpropdef (var92) on <var92:nullable Frame> */
 974 if (unlikely(var92 == NULL)) {
 975 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 976 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 1531);
 977 show_backtrace(1);
 978 }
 979 var97 = var92->attrs[COLOR_abstract_compiler__Frame___mpropdef].val; /* _mpropdef on <var92:nullable Frame> */
 980 if (unlikely(var97 == NULL)) {
 981 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdef");
 982 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 1531);
 983 show_backtrace(1);
 984 }
 985 var95 = var97;
 986 RET_LABEL96:(void)0;
 987 }
 988 }
 989 {
 990 { /* Inline model#MPropDef#mclassdef (var95) on <var95:MPropDef> */
 991 var100 = var95->attrs[COLOR_model__MPropDef___mclassdef].val; /* _mclassdef on <var95:MPropDef> */
 992 if (unlikely(var100 == NULL)) {
 993 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef");
 994 PRINT_ERROR(" (%s:%d)\n", "src/model/model.nit", 1879);
 995 show_backtrace(1);
 996 }
 997 var98 = var100;
 998 RET_LABEL99:(void)0;
 999 }
1000 }
1001 {
1002 { /* Inline model#MClassDef#bound_mtype (var98) on <var98:MClassDef> */
1003 var103 = var98->attrs[COLOR_model__MClassDef___bound_mtype].val; /* _bound_mtype on <var98:MClassDef> */
1004 if (unlikely(var103 == NULL)) {
1005 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype");
1006 PRINT_ERROR(" (%s:%d)\n", "src/model/model.nit", 477);
1007 show_backtrace(1);
1008 }
1009 var101 = var103;
1010 RET_LABEL102:(void)0;
1011 }
1012 }
1013 {
1014 { /* Inline abstract_compiler#AbstractCompilerVisitor#frame (self) on <self:SeparateErasureCompilerVisitor> */
1015 var106 = self->attrs[COLOR_abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on <self:SeparateErasureCompilerVisitor> */
1016 var104 = var106;
1017 RET_LABEL105:(void)0;
1018 }
1019 }
1020 if (var104 == NULL) {
1021 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1022 PRINT_ERROR(" (%s:%d)\n", "src/separate_erasure_compiler.nit", 489);
1023 show_backtrace(1);
1024 } else {
1025 { /* Inline abstract_compiler#Frame#mpropdef (var104) on <var104:nullable Frame> */
1026 if (unlikely(var104 == NULL)) {
1027 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1028 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 1531);
1029 show_backtrace(1);
1030 }
1031 var109 = var104->attrs[COLOR_abstract_compiler__Frame___mpropdef].val; /* _mpropdef on <var104:nullable Frame> */
1032 if (unlikely(var109 == NULL)) {
1033 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdef");
1034 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 1531);
1035 show_backtrace(1);
1036 }
1037 var107 = var109;
1038 RET_LABEL108:(void)0;
1039 }
1040 }
1041 {
1042 { /* Inline model#MPropDef#mclassdef (var107) on <var107:MPropDef> */
1043 var112 = var107->attrs[COLOR_model__MPropDef___mclassdef].val; /* _mclassdef on <var107:MPropDef> */
1044 if (unlikely(var112 == NULL)) {
1045 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef");
1046 PRINT_ERROR(" (%s:%d)\n", "src/model/model.nit", 1879);
1047 show_backtrace(1);
1048 }
1049 var110 = var112;
1050 RET_LABEL111:(void)0;
1051 }
1052 }
1053 {
1054 { /* Inline model#MClassDef#mmodule (var110) on <var110:MClassDef> */
1055 var115 = var110->attrs[COLOR_model__MClassDef___mmodule].val; /* _mmodule on <var110:MClassDef> */
1056 if (unlikely(var115 == NULL)) {
1057 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mmodule");
1058 PRINT_ERROR(" (%s:%d)\n", "src/model/model.nit", 471);
1059 show_backtrace(1);
1060 }
1061 var113 = var115;
1062 RET_LABEL114:(void)0;
1063 }
1064 }
1065 var116 = 0;
1066 {
1067 var117 = model__MParameterType__resolve_for(var_mtype, var89, var101, var113, var116);
1068 }
1069 var_mtype = var117;
1070 /* <var_mtype:MType> isa MNullableType */
1071 cltype119 = type_model__MNullableType.color;
1072 idtype120 = type_model__MNullableType.id;
1073 if(cltype119 >= var_mtype->type->table_size) {
1074 var118 = 0;
1075 } else {
1076 var118 = var_mtype->type->type_table[cltype119] == idtype120;
1077 }
1078 if (var118){
1079 {
1080 { /* Inline model#MNullableType#mtype (var_mtype) on <var_mtype:MType(MNullableType)> */
1081 var123 = var_mtype->attrs[COLOR_model__MNullableType___mtype].val; /* _mtype on <var_mtype:MType(MNullableType)> */
1082 if (unlikely(var123 == NULL)) {
1083 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype");
1084 PRINT_ERROR(" (%s:%d)\n", "src/model/model.nit", 1375);
1085 show_backtrace(1);
1086 }
1087 var121 = var123;
1088 RET_LABEL122:(void)0;
1089 }
1090 }
1091 var_mtype = var121;
1092 if (varonce124) {
1093 var125 = varonce124;
1094 } else {
1095 var126 = "1";
1096 var127 = 1;
1097 var128 = string__NativeString__to_s_with_length(var126, var127);
1098 var125 = var128;
1099 varonce124 = var125;
1100 }
1101 var_accept_null = var125;
1102 } else {
1103 }
1104 } else {
1105 }
1106 {
1107 { /* Inline abstract_compiler#RuntimeVariable#mcasttype (var_value) on <var_value:RuntimeVariable> */
1108 var131 = var_value->attrs[COLOR_abstract_compiler__RuntimeVariable___mcasttype].val; /* _mcasttype on <var_value:RuntimeVariable> */
1109 if (unlikely(var131 == NULL)) {
1110 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mcasttype");
1111 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 1487);
1112 show_backtrace(1);
1113 }
1114 var129 = var131;
1115 RET_LABEL130:(void)0;
1116 }
1117 }
1118 {
1119 { /* Inline abstract_compiler#AbstractCompilerVisitor#frame (self) on <self:SeparateErasureCompilerVisitor> */
1120 var134 = self->attrs[COLOR_abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on <self:SeparateErasureCompilerVisitor> */
1121 var132 = var134;
1122 RET_LABEL133:(void)0;
1123 }
1124 }
1125 if (var132 == NULL) {
1126 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1127 PRINT_ERROR(" (%s:%d)\n", "src/separate_erasure_compiler.nit", 496);
1128 show_backtrace(1);
1129 } else {
1130 { /* Inline abstract_compiler#Frame#mpropdef (var132) on <var132:nullable Frame> */
1131 if (unlikely(var132 == NULL)) {
1132 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1133 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 1531);
1134 show_backtrace(1);
1135 }
1136 var137 = var132->attrs[COLOR_abstract_compiler__Frame___mpropdef].val; /* _mpropdef on <var132:nullable Frame> */
1137 if (unlikely(var137 == NULL)) {
1138 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdef");
1139 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 1531);
1140 show_backtrace(1);
1141 }
1142 var135 = var137;
1143 RET_LABEL136:(void)0;
1144 }
1145 }
1146 {
1147 { /* Inline model#MPropDef#mclassdef (var135) on <var135:MPropDef> */
1148 var140 = var135->attrs[COLOR_model__MPropDef___mclassdef].val; /* _mclassdef on <var135:MPropDef> */
1149 if (unlikely(var140 == NULL)) {
1150 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef");
1151 PRINT_ERROR(" (%s:%d)\n", "src/model/model.nit", 1879);
1152 show_backtrace(1);
1153 }
1154 var138 = var140;
1155 RET_LABEL139:(void)0;
1156 }
1157 }
1158 {
1159 { /* Inline model#MClassDef#mmodule (var138) on <var138:MClassDef> */
1160 var143 = var138->attrs[COLOR_model__MClassDef___mmodule].val; /* _mmodule on <var138:MClassDef> */
1161 if (unlikely(var143 == NULL)) {
1162 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mmodule");
1163 PRINT_ERROR(" (%s:%d)\n", "src/model/model.nit", 471);
1164 show_backtrace(1);
1165 }
1166 var141 = var143;
1167 RET_LABEL142:(void)0;
1168 }
1169 }
1170 {
1171 { /* Inline abstract_compiler#AbstractCompilerVisitor#frame (self) on <self:SeparateErasureCompilerVisitor> */
1172 var146 = self->attrs[COLOR_abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on <self:SeparateErasureCompilerVisitor> */
1173 var144 = var146;
1174 RET_LABEL145:(void)0;
1175 }
1176 }
1177 if (var144 == NULL) {
1178 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1179 PRINT_ERROR(" (%s:%d)\n", "src/separate_erasure_compiler.nit", 496);
1180 show_backtrace(1);
1181 } else {
1182 { /* Inline abstract_compiler#Frame#mpropdef (var144) on <var144:nullable Frame> */
1183 if (unlikely(var144 == NULL)) {
1184 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1185 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 1531);
1186 show_backtrace(1);
1187 }
1188 var149 = var144->attrs[COLOR_abstract_compiler__Frame___mpropdef].val; /* _mpropdef on <var144:nullable Frame> */
1189 if (unlikely(var149 == NULL)) {
1190 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdef");
1191 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 1531);
1192 show_backtrace(1);
1193 }
1194 var147 = var149;
1195 RET_LABEL148:(void)0;
1196 }
1197 }
1198 {
1199 { /* Inline model#MPropDef#mclassdef (var147) on <var147:MPropDef> */
1200 var152 = var147->attrs[COLOR_model__MPropDef___mclassdef].val; /* _mclassdef on <var147:MPropDef> */
1201 if (unlikely(var152 == NULL)) {
1202 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef");
1203 PRINT_ERROR(" (%s:%d)\n", "src/model/model.nit", 1879);
1204 show_backtrace(1);
1205 }
1206 var150 = var152;
1207 RET_LABEL151:(void)0;
1208 }
1209 }
1210 {
1211 { /* Inline model#MClassDef#bound_mtype (var150) on <var150:MClassDef> */
1212 var155 = var150->attrs[COLOR_model__MClassDef___bound_mtype].val; /* _bound_mtype on <var150:MClassDef> */
1213 if (unlikely(var155 == NULL)) {
1214 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype");
1215 PRINT_ERROR(" (%s:%d)\n", "src/model/model.nit", 477);
1216 show_backtrace(1);
1217 }
1218 var153 = var155;
1219 RET_LABEL154:(void)0;
1220 }
1221 }
1222 {
1223 var156 = model__MType__is_subtype(var129, var141, var153, var_mtype);
1224 }
1225 if (var156){
1226 if (varonce157) {
1227 var158 = varonce157;
1228 } else {
1229 var159 = " = 1; /* easy ";
1230 var160 = 14;
1231 var161 = string__NativeString__to_s_with_length(var159, var160);
1232 var158 = var161;
1233 varonce157 = var158;
1234 }
1235 {
1236 var162 = abstract_compiler__RuntimeVariable__inspect(var_value);
1237 }
1238 if (varonce163) {
1239 var164 = varonce163;
1240 } else {
1241 var165 = " isa ";
1242 var166 = 5;
1243 var167 = string__NativeString__to_s_with_length(var165, var166);
1244 var164 = var167;
1245 varonce163 = var164;
1246 }
1247 if (varonce168) {
1248 var169 = varonce168;
1249 } else {
1250 var170 = "*/";
1251 var171 = 2;
1252 var172 = string__NativeString__to_s_with_length(var170, var171);
1253 var169 = var172;
1254 varonce168 = var169;
1255 }
1256 var173 = NEW_array__Array(&type_array__Arraykernel__Object);
1257 { /* var173 = array_instance Array[Object] */
1258 var174 = 6;
1259 var175 = NEW_array__NativeArray(var174, &type_array__NativeArraykernel__Object);
1260 ((struct instance_array__NativeArray*)var175)->values[0] = (val*) var_res;
1261 ((struct instance_array__NativeArray*)var175)->values[1] = (val*) var158;
1262 ((struct instance_array__NativeArray*)var175)->values[2] = (val*) var162;
1263 ((struct instance_array__NativeArray*)var175)->values[3] = (val*) var164;
1264 ((struct instance_array__NativeArray*)var175)->values[4] = (val*) var_mtype;
1265 ((struct instance_array__NativeArray*)var175)->values[5] = (val*) var169;
1266 {
1267 ((void (*)(val*, val*, long))(var173->class->vft[COLOR_array__Array__with_native]))(var173, var175, var174) /* with_native on <var173:Array[Object]>*/;
1268 }
1269 }
1270 {
1271 var176 = ((val* (*)(val*))(var173->class->vft[COLOR_string__Object__to_s]))(var173) /* to_s on <var173:Array[Object]>*/;
1272 }
1273 {
1274 abstract_compiler__AbstractCompilerVisitor__add(self, var176); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
1275 }
1276 {
1277 { /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on <self:SeparateErasureCompilerVisitor> */
1278 var179 = self->attrs[COLOR_abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on <self:SeparateErasureCompilerVisitor> */
1279 if (unlikely(var179 == NULL)) {
1280 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler");
1281 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 984);
1282 show_backtrace(1);
1283 }
1284 var177 = var179;
1285 RET_LABEL178:(void)0;
1286 }
1287 }
1288 {
1289 { /* Inline abstract_compiler#AbstractCompiler#modelbuilder (var177) on <var177:AbstractCompiler(SeparateCompiler)> */
1290 var182 = var177->attrs[COLOR_abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on <var177:AbstractCompiler(SeparateCompiler)> */
1291 if (unlikely(var182 == NULL)) {
1292 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder");
1293 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 443);
1294 show_backtrace(1);
1295 }
1296 var180 = var182;
1297 RET_LABEL181:(void)0;
1298 }
1299 }
1300 {
1301 { /* Inline modelbuilder#ModelBuilder#toolcontext (var180) on <var180:ModelBuilder> */
1302 var185 = var180->attrs[COLOR_modelbuilder__ModelBuilder___toolcontext].val; /* _toolcontext on <var180:ModelBuilder> */
1303 if (unlikely(var185 == NULL)) {
1304 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext");
1305 PRINT_ERROR(" (%s:%d)\n", "src/modelbuilder.nit", 101);
1306 show_backtrace(1);
1307 }
1308 var183 = var185;
1309 RET_LABEL184:(void)0;
1310 }
1311 }
1312 {
1313 { /* Inline abstract_compiler#ToolContext#opt_typing_test_metrics (var183) on <var183:ToolContext> */
1314 var188 = var183->attrs[COLOR_abstract_compiler__ToolContext___opt_typing_test_metrics].val; /* _opt_typing_test_metrics on <var183:ToolContext> */
1315 if (unlikely(var188 == NULL)) {
1316 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_typing_test_metrics");
1317 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 56);
1318 show_backtrace(1);
1319 }
1320 var186 = var188;
1321 RET_LABEL187:(void)0;
1322 }
1323 }
1324 {
1325 { /* Inline opts#Option#value (var186) on <var186:OptionBool> */
1326 var191 = var186->attrs[COLOR_opts__Option___value].val; /* _value on <var186:OptionBool> */
1327 var189 = var191;
1328 RET_LABEL190:(void)0;
1329 }
1330 }
1331 var192 = ((struct instance_kernel__Bool*)var189)->value; /* autounbox from nullable Object to Bool */;
1332 if (var192){
1333 {
1334 { /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on <self:SeparateErasureCompilerVisitor> */
1335 var195 = self->attrs[COLOR_abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on <self:SeparateErasureCompilerVisitor> */
1336 if (unlikely(var195 == NULL)) {
1337 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler");
1338 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 984);
1339 show_backtrace(1);
1340 }
1341 var193 = var195;
1342 RET_LABEL194:(void)0;
1343 }
1344 }
1345 {
1346 { /* Inline abstract_compiler#AbstractCompiler#count_type_test_skipped (var193) on <var193:AbstractCompiler(SeparateCompiler)> */
1347 var198 = var193->attrs[COLOR_abstract_compiler__AbstractCompiler___count_type_test_skipped].val; /* _count_type_test_skipped on <var193:AbstractCompiler(SeparateCompiler)> */
1348 if (unlikely(var198 == NULL)) {
1349 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _count_type_test_skipped");
1350 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 891);
1351 show_backtrace(1);
1352 }
1353 var196 = var198;
1354 RET_LABEL197:(void)0;
1355 }
1356 }
1357 var_ = var196;
1358 var_199 = var_tag;
1359 {
1360 var200 = hash_collection__HashMap___91d_93d(var_, var_199);
1361 }
1362 var201 = 1;
1363 {
1364 { /* Inline kernel#Int#+ (var200,var201) on <var200:nullable Object(Int)> */
1365 /* Covariant cast for argument 0 (i) <var201:Int> isa OTHER */
1366 /* <var201:Int> isa OTHER */
1367 var204 = 1; /* easy <var201:Int> isa OTHER*/
1368 if (unlikely(!var204)) {
1369 var_class_name = type_kernel__Int.name;
1370 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
1371 PRINT_ERROR(" (%s:%d)\n", "lib/standard/kernel.nit", 328);
1372 show_backtrace(1);
1373 }
1374 var207 = ((struct instance_kernel__Int*)var200)->value; /* autounbox from nullable Object to Int */;
1375 var208 = var207 + var201;
1376 var202 = var208;
1377 goto RET_LABEL203;
1378 RET_LABEL203:(void)0;
1379 }
1380 }
1381 {
1382 var209 = BOX_kernel__Int(var202); /* autobox from Int to nullable Object */
1383 hash_collection__HashMap___91d_93d_61d(var_, var_199, var209); /* Direct call hash_collection#HashMap#[]= on <var_:HashMap[String, Int]>*/
1384 }
1385 if (varonce210) {
1386 var211 = varonce210;
1387 } else {
1388 var212 = "count_type_test_skipped_";
1389 var213 = 24;
1390 var214 = string__NativeString__to_s_with_length(var212, var213);
1391 var211 = var214;
1392 varonce210 = var211;
1393 }
1394 if (varonce215) {
1395 var216 = varonce215;
1396 } else {
1397 var217 = "++;";
1398 var218 = 3;
1399 var219 = string__NativeString__to_s_with_length(var217, var218);
1400 var216 = var219;
1401 varonce215 = var216;
1402 }
1403 var220 = NEW_array__Array(&type_array__Arraykernel__Object);
1404 { /* var220 = array_instance Array[Object] */
1405 var221 = 3;
1406 var222 = NEW_array__NativeArray(var221, &type_array__NativeArraykernel__Object);
1407 ((struct instance_array__NativeArray*)var222)->values[0] = (val*) var211;
1408 ((struct instance_array__NativeArray*)var222)->values[1] = (val*) var_tag;
1409 ((struct instance_array__NativeArray*)var222)->values[2] = (val*) var216;
1410 {
1411 ((void (*)(val*, val*, long))(var220->class->vft[COLOR_array__Array__with_native]))(var220, var222, var221) /* with_native on <var220:Array[Object]>*/;
1412 }
1413 }
1414 {
1415 var223 = ((val* (*)(val*))(var220->class->vft[COLOR_string__Object__to_s]))(var220) /* to_s on <var220:Array[Object]>*/;
1416 }
1417 {
1418 abstract_compiler__AbstractCompilerVisitor__add(self, var223); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
1419 }
1420 } else {
1421 }
1422 var = var_res;
1423 goto RET_LABEL;
1424 } else {
1425 }
1426 {
1427 { /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on <var_value:RuntimeVariable> */
1428 var226 = var_value->attrs[COLOR_abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on <var_value:RuntimeVariable> */
1429 if (unlikely(var226 == NULL)) {
1430 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype");
1431 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 1484);
1432 show_backtrace(1);
1433 }
1434 var224 = var226;
1435 RET_LABEL225:(void)0;
1436 }
1437 }
1438 {
1439 var227 = ((val* (*)(val*))(var224->class->vft[COLOR_abstract_compiler__MType__ctype]))(var224) /* ctype on <var224:MType>*/;
1440 }
1441 if (varonce228) {
1442 var229 = varonce228;
1443 } else {
1444 var230 = "val*";
1445 var231 = 4;
1446 var232 = string__NativeString__to_s_with_length(var230, var231);
1447 var229 = var232;
1448 varonce228 = var229;
1449 }
1450 {
1451 var234 = string__FlatString___61d_61d(var227, var229);
1452 var233 = var234;
1453 }
1454 if (var233){
1455 if (varonce235) {
1456 var236 = varonce235;
1457 } else {
1458 var237 = "->class->";
1459 var238 = 9;
1460 var239 = string__NativeString__to_s_with_length(var237, var238);
1461 var236 = var239;
1462 varonce235 = var236;
1463 }
1464 var240 = NEW_array__Array(&type_array__Arraykernel__Object);
1465 { /* var240 = array_instance Array[Object] */
1466 var241 = 2;
1467 var242 = NEW_array__NativeArray(var241, &type_array__NativeArraykernel__Object);
1468 ((struct instance_array__NativeArray*)var242)->values[0] = (val*) var_value;
1469 ((struct instance_array__NativeArray*)var242)->values[1] = (val*) var236;
1470 {
1471 ((void (*)(val*, val*, long))(var240->class->vft[COLOR_array__Array__with_native]))(var240, var242, var241) /* with_native on <var240:Array[Object]>*/;
1472 }
1473 }
1474 {
1475 var243 = ((val* (*)(val*))(var240->class->vft[COLOR_string__Object__to_s]))(var240) /* to_s on <var240:Array[Object]>*/;
1476 }
1477 var_class_ptr = var243;
1478 } else {
1479 {
1480 { /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on <var_value:RuntimeVariable> */
1481 var246 = var_value->attrs[COLOR_abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on <var_value:RuntimeVariable> */
1482 if (unlikely(var246 == NULL)) {
1483 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype");
1484 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 1484);
1485 show_backtrace(1);
1486 }
1487 var244 = var246;
1488 RET_LABEL245:(void)0;
1489 }
1490 }
1491 /* <var244:MType> isa MClassType */
1492 cltype248 = type_model__MClassType.color;
1493 idtype249 = type_model__MClassType.id;
1494 if(cltype248 >= var244->type->table_size) {
1495 var247 = 0;
1496 } else {
1497 var247 = var244->type->type_table[cltype248] == idtype249;
1498 }
1499 if (unlikely(!var247)) {
1500 var_class_name250 = var244 == NULL ? "null" : var244->type->name;
1501 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name250);
1502 PRINT_ERROR(" (%s:%d)\n", "src/separate_erasure_compiler.nit", 510);
1503 show_backtrace(1);
1504 }
1505 {
1506 { /* Inline model#MClassType#mclass (var244) on <var244:MType(MClassType)> */
1507 var253 = var244->attrs[COLOR_model__MClassType___mclass].val; /* _mclass on <var244:MType(MClassType)> */
1508 if (unlikely(var253 == NULL)) {
1509 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
1510 PRINT_ERROR(" (%s:%d)\n", "src/model/model.nit", 969);
1511 show_backtrace(1);
1512 }
1513 var251 = var253;
1514 RET_LABEL252:(void)0;
1515 }
1516 }
1517 var_mclass = var251;
1518 if (varonce254) {
1519 var255 = varonce254;
1520 } else {
1521 var256 = "class_";
1522 var257 = 6;
1523 var258 = string__NativeString__to_s_with_length(var256, var257);
1524 var255 = var258;
1525 varonce254 = var255;
1526 }
1527 {
1528 var259 = abstract_compiler__MClass__c_name(var_mclass);
1529 }
1530 var260 = NEW_array__Array(&type_array__Arraykernel__Object);
1531 { /* var260 = array_instance Array[Object] */
1532 var261 = 2;
1533 var262 = NEW_array__NativeArray(var261, &type_array__NativeArraykernel__Object);
1534 ((struct instance_array__NativeArray*)var262)->values[0] = (val*) var255;
1535 ((struct instance_array__NativeArray*)var262)->values[1] = (val*) var259;
1536 {
1537 ((void (*)(val*, val*, long))(var260->class->vft[COLOR_array__Array__with_native]))(var260, var262, var261) /* with_native on <var260:Array[Object]>*/;
1538 }
1539 }
1540 {
1541 var263 = ((val* (*)(val*))(var260->class->vft[COLOR_string__Object__to_s]))(var260) /* to_s on <var260:Array[Object]>*/;
1542 }
1543 {
1544 abstract_compiler__AbstractCompilerVisitor__require_declaration(self, var263); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on <self:SeparateErasureCompilerVisitor>*/
1545 }
1546 if (varonce264) {
1547 var265 = varonce264;
1548 } else {
1549 var266 = "class_";
1550 var267 = 6;
1551 var268 = string__NativeString__to_s_with_length(var266, var267);
1552 var265 = var268;
1553 varonce264 = var265;
1554 }
1555 {
1556 var269 = abstract_compiler__MClass__c_name(var_mclass);
1557 }
1558 if (varonce270) {
1559 var271 = varonce270;
1560 } else {
1561 var272 = ".";
1562 var273 = 1;
1563 var274 = string__NativeString__to_s_with_length(var272, var273);
1564 var271 = var274;
1565 varonce270 = var271;
1566 }
1567 var275 = NEW_array__Array(&type_array__Arraykernel__Object);
1568 { /* var275 = array_instance Array[Object] */
1569 var276 = 3;
1570 var277 = NEW_array__NativeArray(var276, &type_array__NativeArraykernel__Object);
1571 ((struct instance_array__NativeArray*)var277)->values[0] = (val*) var265;
1572 ((struct instance_array__NativeArray*)var277)->values[1] = (val*) var269;
1573 ((struct instance_array__NativeArray*)var277)->values[2] = (val*) var271;
1574 {
1575 ((void (*)(val*, val*, long))(var275->class->vft[COLOR_array__Array__with_native]))(var275, var277, var276) /* with_native on <var275:Array[Object]>*/;
1576 }
1577 }
1578 {
1579 var278 = ((val* (*)(val*))(var275->class->vft[COLOR_string__Object__to_s]))(var275) /* to_s on <var275:Array[Object]>*/;
1580 }
1581 var_class_ptr = var278;
1582 }
1583 /* <var_mtype:MType> isa MClassType */
1584 cltype280 = type_model__MClassType.color;
1585 idtype281 = type_model__MClassType.id;
1586 if(cltype280 >= var_mtype->type->table_size) {
1587 var279 = 0;
1588 } else {
1589 var279 = var_mtype->type->type_table[cltype280] == idtype281;
1590 }
1591 if (var279){
1592 if (varonce282) {
1593 var283 = varonce282;
1594 } else {
1595 var284 = "class_";
1596 var285 = 6;
1597 var286 = string__NativeString__to_s_with_length(var284, var285);
1598 var283 = var286;
1599 varonce282 = var283;
1600 }
1601 {
1602 { /* Inline model#MClassType#mclass (var_mtype) on <var_mtype:MType(MClassType)> */
1603 var289 = var_mtype->attrs[COLOR_model__MClassType___mclass].val; /* _mclass on <var_mtype:MType(MClassType)> */
1604 if (unlikely(var289 == NULL)) {
1605 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
1606 PRINT_ERROR(" (%s:%d)\n", "src/model/model.nit", 969);
1607 show_backtrace(1);
1608 }
1609 var287 = var289;
1610 RET_LABEL288:(void)0;
1611 }
1612 }
1613 {
1614 var290 = abstract_compiler__MClass__c_name(var287);
1615 }
1616 var291 = NEW_array__Array(&type_array__Arraykernel__Object);
1617 { /* var291 = array_instance Array[Object] */
1618 var292 = 2;
1619 var293 = NEW_array__NativeArray(var292, &type_array__NativeArraykernel__Object);
1620 ((struct instance_array__NativeArray*)var293)->values[0] = (val*) var283;
1621 ((struct instance_array__NativeArray*)var293)->values[1] = (val*) var290;
1622 {
1623 ((void (*)(val*, val*, long))(var291->class->vft[COLOR_array__Array__with_native]))(var291, var293, var292) /* with_native on <var291:Array[Object]>*/;
1624 }
1625 }
1626 {
1627 var294 = ((val* (*)(val*))(var291->class->vft[COLOR_string__Object__to_s]))(var291) /* to_s on <var291:Array[Object]>*/;
1628 }
1629 {
1630 abstract_compiler__AbstractCompilerVisitor__require_declaration(self, var294); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on <self:SeparateErasureCompilerVisitor>*/
1631 }
1632 if (varonce295) {
1633 var296 = varonce295;
1634 } else {
1635 var297 = " = class_";
1636 var298 = 9;
1637 var299 = string__NativeString__to_s_with_length(var297, var298);
1638 var296 = var299;
1639 varonce295 = var296;
1640 }
1641 {
1642 { /* Inline model#MClassType#mclass (var_mtype) on <var_mtype:MType(MClassType)> */
1643 var302 = var_mtype->attrs[COLOR_model__MClassType___mclass].val; /* _mclass on <var_mtype:MType(MClassType)> */
1644 if (unlikely(var302 == NULL)) {
1645 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
1646 PRINT_ERROR(" (%s:%d)\n", "src/model/model.nit", 969);
1647 show_backtrace(1);
1648 }
1649 var300 = var302;
1650 RET_LABEL301:(void)0;
1651 }
1652 }
1653 {
1654 var303 = abstract_compiler__MClass__c_name(var300);
1655 }
1656 if (varonce304) {
1657 var305 = varonce304;
1658 } else {
1659 var306 = ".color;";
1660 var307 = 7;
1661 var308 = string__NativeString__to_s_with_length(var306, var307);
1662 var305 = var308;
1663 varonce304 = var305;
1664 }
1665 var309 = NEW_array__Array(&type_array__Arraykernel__Object);
1666 { /* var309 = array_instance Array[Object] */
1667 var310 = 4;
1668 var311 = NEW_array__NativeArray(var310, &type_array__NativeArraykernel__Object);
1669 ((struct instance_array__NativeArray*)var311)->values[0] = (val*) var_cltype;
1670 ((struct instance_array__NativeArray*)var311)->values[1] = (val*) var296;
1671 ((struct instance_array__NativeArray*)var311)->values[2] = (val*) var303;
1672 ((struct instance_array__NativeArray*)var311)->values[3] = (val*) var305;
1673 {
1674 ((void (*)(val*, val*, long))(var309->class->vft[COLOR_array__Array__with_native]))(var309, var311, var310) /* with_native on <var309:Array[Object]>*/;
1675 }
1676 }
1677 {
1678 var312 = ((val* (*)(val*))(var309->class->vft[COLOR_string__Object__to_s]))(var309) /* to_s on <var309:Array[Object]>*/;
1679 }
1680 {
1681 abstract_compiler__AbstractCompilerVisitor__add(self, var312); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
1682 }
1683 if (varonce313) {
1684 var314 = varonce313;
1685 } else {
1686 var315 = " = class_";
1687 var316 = 9;
1688 var317 = string__NativeString__to_s_with_length(var315, var316);
1689 var314 = var317;
1690 varonce313 = var314;
1691 }
1692 {
1693 { /* Inline model#MClassType#mclass (var_mtype) on <var_mtype:MType(MClassType)> */
1694 var320 = var_mtype->attrs[COLOR_model__MClassType___mclass].val; /* _mclass on <var_mtype:MType(MClassType)> */
1695 if (unlikely(var320 == NULL)) {
1696 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
1697 PRINT_ERROR(" (%s:%d)\n", "src/model/model.nit", 969);
1698 show_backtrace(1);
1699 }
1700 var318 = var320;
1701 RET_LABEL319:(void)0;
1702 }
1703 }
1704 {
1705 var321 = abstract_compiler__MClass__c_name(var318);
1706 }
1707 if (varonce322) {
1708 var323 = varonce322;
1709 } else {
1710 var324 = ".id;";
1711 var325 = 4;
1712 var326 = string__NativeString__to_s_with_length(var324, var325);
1713 var323 = var326;
1714 varonce322 = var323;
1715 }
1716 var327 = NEW_array__Array(&type_array__Arraykernel__Object);
1717 { /* var327 = array_instance Array[Object] */
1718 var328 = 4;
1719 var329 = NEW_array__NativeArray(var328, &type_array__NativeArraykernel__Object);
1720 ((struct instance_array__NativeArray*)var329)->values[0] = (val*) var_idtype;
1721 ((struct instance_array__NativeArray*)var329)->values[1] = (val*) var314;
1722 ((struct instance_array__NativeArray*)var329)->values[2] = (val*) var321;
1723 ((struct instance_array__NativeArray*)var329)->values[3] = (val*) var323;
1724 {
1725 ((void (*)(val*, val*, long))(var327->class->vft[COLOR_array__Array__with_native]))(var327, var329, var328) /* with_native on <var327:Array[Object]>*/;
1726 }
1727 }
1728 {
1729 var330 = ((val* (*)(val*))(var327->class->vft[COLOR_string__Object__to_s]))(var327) /* to_s on <var327:Array[Object]>*/;
1730 }
1731 {
1732 abstract_compiler__AbstractCompilerVisitor__add(self, var330); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
1733 }
1734 {
1735 { /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on <self:SeparateErasureCompilerVisitor> */
1736 var333 = self->attrs[COLOR_abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on <self:SeparateErasureCompilerVisitor> */
1737 if (unlikely(var333 == NULL)) {
1738 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler");
1739 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 984);
1740 show_backtrace(1);
1741 }
1742 var331 = var333;
1743 RET_LABEL332:(void)0;
1744 }
1745 }
1746 {
1747 { /* Inline abstract_compiler#AbstractCompiler#modelbuilder (var331) on <var331:AbstractCompiler(SeparateCompiler)> */
1748 var336 = var331->attrs[COLOR_abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on <var331:AbstractCompiler(SeparateCompiler)> */
1749 if (unlikely(var336 == NULL)) {
1750 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder");
1751 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 443);
1752 show_backtrace(1);
1753 }
1754 var334 = var336;
1755 RET_LABEL335:(void)0;
1756 }
1757 }
1758 {
1759 { /* Inline modelbuilder#ModelBuilder#toolcontext (var334) on <var334:ModelBuilder> */
1760 var339 = var334->attrs[COLOR_modelbuilder__ModelBuilder___toolcontext].val; /* _toolcontext on <var334:ModelBuilder> */
1761 if (unlikely(var339 == NULL)) {
1762 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext");
1763 PRINT_ERROR(" (%s:%d)\n", "src/modelbuilder.nit", 101);
1764 show_backtrace(1);
1765 }
1766 var337 = var339;
1767 RET_LABEL338:(void)0;
1768 }
1769 }
1770 {
1771 { /* Inline abstract_compiler#ToolContext#opt_typing_test_metrics (var337) on <var337:ToolContext> */
1772 var342 = var337->attrs[COLOR_abstract_compiler__ToolContext___opt_typing_test_metrics].val; /* _opt_typing_test_metrics on <var337:ToolContext> */
1773 if (unlikely(var342 == NULL)) {
1774 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_typing_test_metrics");
1775 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 56);
1776 show_backtrace(1);
1777 }
1778 var340 = var342;
1779 RET_LABEL341:(void)0;
1780 }
1781 }
1782 {
1783 { /* Inline opts#Option#value (var340) on <var340:OptionBool> */
1784 var345 = var340->attrs[COLOR_opts__Option___value].val; /* _value on <var340:OptionBool> */
1785 var343 = var345;
1786 RET_LABEL344:(void)0;
1787 }
1788 }
1789 var346 = ((struct instance_kernel__Bool*)var343)->value; /* autounbox from nullable Object to Bool */;
1790 if (var346){
1791 {
1792 { /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on <self:SeparateErasureCompilerVisitor> */
1793 var349 = self->attrs[COLOR_abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on <self:SeparateErasureCompilerVisitor> */
1794 if (unlikely(var349 == NULL)) {
1795 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler");
1796 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 984);
1797 show_backtrace(1);
1798 }
1799 var347 = var349;
1800 RET_LABEL348:(void)0;
1801 }
1802 }
1803 {
1804 { /* Inline abstract_compiler#AbstractCompiler#count_type_test_resolved (var347) on <var347:AbstractCompiler(SeparateCompiler)> */
1805 var352 = var347->attrs[COLOR_abstract_compiler__AbstractCompiler___count_type_test_resolved].val; /* _count_type_test_resolved on <var347:AbstractCompiler(SeparateCompiler)> */
1806 if (unlikely(var352 == NULL)) {
1807 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _count_type_test_resolved");
1808 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 889);
1809 show_backtrace(1);
1810 }
1811 var350 = var352;
1812 RET_LABEL351:(void)0;
1813 }
1814 }
1815 var_353 = var350;
1816 var_354 = var_tag;
1817 {
1818 var355 = hash_collection__HashMap___91d_93d(var_353, var_354);
1819 }
1820 var356 = 1;
1821 {
1822 { /* Inline kernel#Int#+ (var355,var356) on <var355:nullable Object(Int)> */
1823 /* Covariant cast for argument 0 (i) <var356:Int> isa OTHER */
1824 /* <var356:Int> isa OTHER */
1825 var359 = 1; /* easy <var356:Int> isa OTHER*/
1826 if (unlikely(!var359)) {
1827 var_class_name362 = type_kernel__Int.name;
1828 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name362);
1829 PRINT_ERROR(" (%s:%d)\n", "lib/standard/kernel.nit", 328);
1830 show_backtrace(1);
1831 }
1832 var363 = ((struct instance_kernel__Int*)var355)->value; /* autounbox from nullable Object to Int */;
1833 var364 = var363 + var356;
1834 var357 = var364;
1835 goto RET_LABEL358;
1836 RET_LABEL358:(void)0;
1837 }
1838 }
1839 {
1840 var365 = BOX_kernel__Int(var357); /* autobox from Int to nullable Object */
1841 hash_collection__HashMap___91d_93d_61d(var_353, var_354, var365); /* Direct call hash_collection#HashMap#[]= on <var_353:HashMap[String, Int]>*/
1842 }
1843 if (varonce366) {
1844 var367 = varonce366;
1845 } else {
1846 var368 = "count_type_test_resolved_";
1847 var369 = 25;
1848 var370 = string__NativeString__to_s_with_length(var368, var369);
1849 var367 = var370;
1850 varonce366 = var367;
1851 }
1852 if (varonce371) {
1853 var372 = varonce371;
1854 } else {
1855 var373 = "++;";
1856 var374 = 3;
1857 var375 = string__NativeString__to_s_with_length(var373, var374);
1858 var372 = var375;
1859 varonce371 = var372;
1860 }
1861 var376 = NEW_array__Array(&type_array__Arraykernel__Object);
1862 { /* var376 = array_instance Array[Object] */
1863 var377 = 3;
1864 var378 = NEW_array__NativeArray(var377, &type_array__NativeArraykernel__Object);
1865 ((struct instance_array__NativeArray*)var378)->values[0] = (val*) var367;
1866 ((struct instance_array__NativeArray*)var378)->values[1] = (val*) var_tag;
1867 ((struct instance_array__NativeArray*)var378)->values[2] = (val*) var372;
1868 {
1869 ((void (*)(val*, val*, long))(var376->class->vft[COLOR_array__Array__with_native]))(var376, var378, var377) /* with_native on <var376:Array[Object]>*/;
1870 }
1871 }
1872 {
1873 var379 = ((val* (*)(val*))(var376->class->vft[COLOR_string__Object__to_s]))(var376) /* to_s on <var376:Array[Object]>*/;
1874 }
1875 {
1876 abstract_compiler__AbstractCompilerVisitor__add(self, var379); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
1877 }
1878 } else {
1879 }
1880 } else {
1881 /* <var_mtype:MType> isa MVirtualType */
1882 cltype381 = type_model__MVirtualType.color;
1883 idtype382 = type_model__MVirtualType.id;
1884 if(cltype381 >= var_mtype->type->table_size) {
1885 var380 = 0;
1886 } else {
1887 var380 = var_mtype->type->type_table[cltype381] == idtype382;
1888 }
1889 if (var380){
1890 {
1891 { /* Inline abstract_compiler#AbstractCompilerVisitor#frame (self) on <self:SeparateErasureCompilerVisitor> */
1892 var385 = self->attrs[COLOR_abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on <self:SeparateErasureCompilerVisitor> */
1893 var383 = var385;
1894 RET_LABEL384:(void)0;
1895 }
1896 }
1897 if (var383 == NULL) {
1898 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1899 PRINT_ERROR(" (%s:%d)\n", "src/separate_erasure_compiler.nit", 524);
1900 show_backtrace(1);
1901 } else {
1902 { /* Inline abstract_compiler#Frame#arguments (var383) on <var383:nullable Frame> */
1903 if (unlikely(var383 == NULL)) {
1904 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1905 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 1538);
1906 show_backtrace(1);
1907 }
1908 var388 = var383->attrs[COLOR_abstract_compiler__Frame___arguments].val; /* _arguments on <var383:nullable Frame> */
1909 if (unlikely(var388 == NULL)) {
1910 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _arguments");
1911 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 1538);
1912 show_backtrace(1);
1913 }
1914 var386 = var388;
1915 RET_LABEL387:(void)0;
1916 }
1917 }
1918 {
1919 var389 = abstract_collection__SequenceRead__first(var386);
1920 }
1921 var_recv = var389;
1922 {
1923 { /* Inline abstract_compiler#RuntimeVariable#mtype (var_recv) on <var_recv:RuntimeVariable> */
1924 var392 = var_recv->attrs[COLOR_abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on <var_recv:RuntimeVariable> */
1925 if (unlikely(var392 == NULL)) {
1926 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype");
1927 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 1484);
1928 show_backtrace(1);
1929 }
1930 var390 = var392;
1931 RET_LABEL391:(void)0;
1932 }
1933 }
1934 {
1935 var393 = ((val* (*)(val*))(var390->class->vft[COLOR_abstract_compiler__MType__ctype]))(var390) /* ctype on <var390:MType>*/;
1936 }
1937 if (varonce394) {
1938 var395 = varonce394;
1939 } else {
1940 var396 = "val*";
1941 var397 = 4;
1942 var398 = string__NativeString__to_s_with_length(var396, var397);
1943 var395 = var398;
1944 varonce394 = var395;
1945 }
1946 {
1947 var400 = string__FlatString___61d_61d(var393, var395);
1948 var399 = var400;
1949 }
1950 if (var399){
1951 if (varonce401) {
1952 var402 = varonce401;
1953 } else {
1954 var403 = "->class->";
1955 var404 = 9;
1956 var405 = string__NativeString__to_s_with_length(var403, var404);
1957 var402 = var405;
1958 varonce401 = var402;
1959 }
1960 var406 = NEW_array__Array(&type_array__Arraykernel__Object);
1961 { /* var406 = array_instance Array[Object] */
1962 var407 = 2;
1963 var408 = NEW_array__NativeArray(var407, &type_array__NativeArraykernel__Object);
1964 ((struct instance_array__NativeArray*)var408)->values[0] = (val*) var_recv;
1965 ((struct instance_array__NativeArray*)var408)->values[1] = (val*) var402;
1966 {
1967 ((void (*)(val*, val*, long))(var406->class->vft[COLOR_array__Array__with_native]))(var406, var408, var407) /* with_native on <var406:Array[Object]>*/;
1968 }
1969 }
1970 {
1971 var409 = ((val* (*)(val*))(var406->class->vft[COLOR_string__Object__to_s]))(var406) /* to_s on <var406:Array[Object]>*/;
1972 }
1973 var_recv_ptr = var409;
1974 } else {
1975 {
1976 { /* Inline abstract_compiler#RuntimeVariable#mtype (var_recv) on <var_recv:RuntimeVariable> */
1977 var412 = var_recv->attrs[COLOR_abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on <var_recv:RuntimeVariable> */
1978 if (unlikely(var412 == NULL)) {
1979 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype");
1980 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 1484);
1981 show_backtrace(1);
1982 }
1983 var410 = var412;
1984 RET_LABEL411:(void)0;
1985 }
1986 }
1987 /* <var410:MType> isa MClassType */
1988 cltype414 = type_model__MClassType.color;
1989 idtype415 = type_model__MClassType.id;
1990 if(cltype414 >= var410->type->table_size) {
1991 var413 = 0;
1992 } else {
1993 var413 = var410->type->type_table[cltype414] == idtype415;
1994 }
1995 if (unlikely(!var413)) {
1996 var_class_name416 = var410 == NULL ? "null" : var410->type->name;
1997 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name416);
1998 PRINT_ERROR(" (%s:%d)\n", "src/separate_erasure_compiler.nit", 529);
1999 show_backtrace(1);
2000 }
2001 {
2002 { /* Inline model#MClassType#mclass (var410) on <var410:MType(MClassType)> */
2003 var419 = var410->attrs[COLOR_model__MClassType___mclass].val; /* _mclass on <var410:MType(MClassType)> */
2004 if (unlikely(var419 == NULL)) {
2005 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
2006 PRINT_ERROR(" (%s:%d)\n", "src/model/model.nit", 969);
2007 show_backtrace(1);
2008 }
2009 var417 = var419;
2010 RET_LABEL418:(void)0;
2011 }
2012 }
2013 var_mclass420 = var417;
2014 if (varonce421) {
2015 var422 = varonce421;
2016 } else {
2017 var423 = "class_";
2018 var424 = 6;
2019 var425 = string__NativeString__to_s_with_length(var423, var424);
2020 var422 = var425;
2021 varonce421 = var422;
2022 }
2023 {
2024 var426 = abstract_compiler__MClass__c_name(var_mclass420);
2025 }
2026 var427 = NEW_array__Array(&type_array__Arraykernel__Object);
2027 { /* var427 = array_instance Array[Object] */
2028 var428 = 2;
2029 var429 = NEW_array__NativeArray(var428, &type_array__NativeArraykernel__Object);
2030 ((struct instance_array__NativeArray*)var429)->values[0] = (val*) var422;
2031 ((struct instance_array__NativeArray*)var429)->values[1] = (val*) var426;
2032 {
2033 ((void (*)(val*, val*, long))(var427->class->vft[COLOR_array__Array__with_native]))(var427, var429, var428) /* with_native on <var427:Array[Object]>*/;
2034 }
2035 }
2036 {
2037 var430 = ((val* (*)(val*))(var427->class->vft[COLOR_string__Object__to_s]))(var427) /* to_s on <var427:Array[Object]>*/;
2038 }
2039 {
2040 abstract_compiler__AbstractCompilerVisitor__require_declaration(self, var430); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on <self:SeparateErasureCompilerVisitor>*/
2041 }
2042 if (varonce431) {
2043 var432 = varonce431;
2044 } else {
2045 var433 = "class_";
2046 var434 = 6;
2047 var435 = string__NativeString__to_s_with_length(var433, var434);
2048 var432 = var435;
2049 varonce431 = var432;
2050 }
2051 {
2052 var436 = abstract_compiler__MClass__c_name(var_mclass420);
2053 }
2054 if (varonce437) {
2055 var438 = varonce437;
2056 } else {
2057 var439 = ".";
2058 var440 = 1;
2059 var441 = string__NativeString__to_s_with_length(var439, var440);
2060 var438 = var441;
2061 varonce437 = var438;
2062 }
2063 var442 = NEW_array__Array(&type_array__Arraykernel__Object);
2064 { /* var442 = array_instance Array[Object] */
2065 var443 = 3;
2066 var444 = NEW_array__NativeArray(var443, &type_array__NativeArraykernel__Object);
2067 ((struct instance_array__NativeArray*)var444)->values[0] = (val*) var432;
2068 ((struct instance_array__NativeArray*)var444)->values[1] = (val*) var436;
2069 ((struct instance_array__NativeArray*)var444)->values[2] = (val*) var438;
2070 {
2071 ((void (*)(val*, val*, long))(var442->class->vft[COLOR_array__Array__with_native]))(var442, var444, var443) /* with_native on <var442:Array[Object]>*/;
2072 }
2073 }
2074 {
2075 var445 = ((val* (*)(val*))(var442->class->vft[COLOR_string__Object__to_s]))(var442) /* to_s on <var442:Array[Object]>*/;
2076 }
2077 var_recv_ptr = var445;
2078 }
2079 if (varonce446) {
2080 var447 = varonce446;
2081 } else {
2082 var448 = "entry";
2083 var449 = 5;
2084 var450 = string__NativeString__to_s_with_length(var448, var449);
2085 var447 = var450;
2086 varonce446 = var447;
2087 }
2088 {
2089 var451 = abstract_compiler__AbstractCompilerVisitor__get_name(self, var447);
2090 }
2091 var_entry = var451;
2092 if (varonce452) {
2093 var453 = varonce452;
2094 } else {
2095 var454 = "struct vts_entry ";
2096 var455 = 17;
2097 var456 = string__NativeString__to_s_with_length(var454, var455);
2098 var453 = var456;
2099 varonce452 = var453;
2100 }
2101 if (varonce457) {
2102 var458 = varonce457;
2103 } else {
2104 var459 = ";";
2105 var460 = 1;
2106 var461 = string__NativeString__to_s_with_length(var459, var460);
2107 var458 = var461;
2108 varonce457 = var458;
2109 }
2110 var462 = NEW_array__Array(&type_array__Arraykernel__Object);
2111 { /* var462 = array_instance Array[Object] */
2112 var463 = 3;
2113 var464 = NEW_array__NativeArray(var463, &type_array__NativeArraykernel__Object);
2114 ((struct instance_array__NativeArray*)var464)->values[0] = (val*) var453;
2115 ((struct instance_array__NativeArray*)var464)->values[1] = (val*) var_entry;
2116 ((struct instance_array__NativeArray*)var464)->values[2] = (val*) var458;
2117 {
2118 ((void (*)(val*, val*, long))(var462->class->vft[COLOR_array__Array__with_native]))(var462, var464, var463) /* with_native on <var462:Array[Object]>*/;
2119 }
2120 }
2121 {
2122 var465 = ((val* (*)(val*))(var462->class->vft[COLOR_string__Object__to_s]))(var462) /* to_s on <var462:Array[Object]>*/;
2123 }
2124 {
2125 abstract_compiler__AbstractCompilerVisitor__add(self, var465); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
2126 }
2127 {
2128 { /* Inline model#MVirtualType#mproperty (var_mtype) on <var_mtype:MType(MVirtualType)> */
2129 var468 = var_mtype->attrs[COLOR_model__MVirtualType___mproperty].val; /* _mproperty on <var_mtype:MType(MVirtualType)> */
2130 if (unlikely(var468 == NULL)) {
2131 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mproperty");
2132 PRINT_ERROR(" (%s:%d)\n", "src/model/model.nit", 1135);
2133 show_backtrace(1);
2134 }
2135 var466 = var468;
2136 RET_LABEL467:(void)0;
2137 }
2138 }
2139 {
2140 var469 = separate_compiler__MProperty__const_color(var466);
2141 }
2142 {
2143 abstract_compiler__AbstractCompilerVisitor__require_declaration(self, var469); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on <self:SeparateErasureCompilerVisitor>*/
2144 }
2145 if (varonce470) {
2146 var471 = varonce470;
2147 } else {
2148 var472 = " = ";
2149 var473 = 3;
2150 var474 = string__NativeString__to_s_with_length(var472, var473);
2151 var471 = var474;
2152 varonce470 = var471;
2153 }
2154 if (varonce475) {
2155 var476 = varonce475;
2156 } else {
2157 var477 = "vts_table->vts[";
2158 var478 = 15;
2159 var479 = string__NativeString__to_s_with_length(var477, var478);
2160 var476 = var479;
2161 varonce475 = var476;
2162 }
2163 {
2164 { /* Inline model#MVirtualType#mproperty (var_mtype) on <var_mtype:MType(MVirtualType)> */
2165 var482 = var_mtype->attrs[COLOR_model__MVirtualType___mproperty].val; /* _mproperty on <var_mtype:MType(MVirtualType)> */
2166 if (unlikely(var482 == NULL)) {
2167 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mproperty");
2168 PRINT_ERROR(" (%s:%d)\n", "src/model/model.nit", 1135);
2169 show_backtrace(1);
2170 }
2171 var480 = var482;
2172 RET_LABEL481:(void)0;
2173 }
2174 }
2175 {
2176 var483 = separate_compiler__MProperty__const_color(var480);
2177 }
2178 if (varonce484) {
2179 var485 = varonce484;
2180 } else {
2181 var486 = "];";
2182 var487 = 2;
2183 var488 = string__NativeString__to_s_with_length(var486, var487);
2184 var485 = var488;
2185 varonce484 = var485;
2186 }
2187 var489 = NEW_array__Array(&type_array__Arraykernel__Object);
2188 { /* var489 = array_instance Array[Object] */
2189 var490 = 6;
2190 var491 = NEW_array__NativeArray(var490, &type_array__NativeArraykernel__Object);
2191 ((struct instance_array__NativeArray*)var491)->values[0] = (val*) var_entry;
2192 ((struct instance_array__NativeArray*)var491)->values[1] = (val*) var471;
2193 ((struct instance_array__NativeArray*)var491)->values[2] = (val*) var_recv_ptr;
2194 ((struct instance_array__NativeArray*)var491)->values[3] = (val*) var476;
2195 ((struct instance_array__NativeArray*)var491)->values[4] = (val*) var483;
2196 ((struct instance_array__NativeArray*)var491)->values[5] = (val*) var485;
2197 {
2198 ((void (*)(val*, val*, long))(var489->class->vft[COLOR_array__Array__with_native]))(var489, var491, var490) /* with_native on <var489:Array[Object]>*/;
2199 }
2200 }
2201 {
2202 var492 = ((val* (*)(val*))(var489->class->vft[COLOR_string__Object__to_s]))(var489) /* to_s on <var489:Array[Object]>*/;
2203 }
2204 {
2205 abstract_compiler__AbstractCompilerVisitor__add(self, var492); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
2206 }
2207 if (varonce493) {
2208 var494 = varonce493;
2209 } else {
2210 var495 = " = ";
2211 var496 = 3;
2212 var497 = string__NativeString__to_s_with_length(var495, var496);
2213 var494 = var497;
2214 varonce493 = var494;
2215 }
2216 if (varonce498) {
2217 var499 = varonce498;
2218 } else {
2219 var500 = ".class->color;";
2220 var501 = 14;
2221 var502 = string__NativeString__to_s_with_length(var500, var501);
2222 var499 = var502;
2223 varonce498 = var499;
2224 }
2225 var503 = NEW_array__Array(&type_array__Arraykernel__Object);
2226 { /* var503 = array_instance Array[Object] */
2227 var504 = 4;
2228 var505 = NEW_array__NativeArray(var504, &type_array__NativeArraykernel__Object);
2229 ((struct instance_array__NativeArray*)var505)->values[0] = (val*) var_cltype;
2230 ((struct instance_array__NativeArray*)var505)->values[1] = (val*) var494;
2231 ((struct instance_array__NativeArray*)var505)->values[2] = (val*) var_entry;
2232 ((struct instance_array__NativeArray*)var505)->values[3] = (val*) var499;
2233 {
2234 ((void (*)(val*, val*, long))(var503->class->vft[COLOR_array__Array__with_native]))(var503, var505, var504) /* with_native on <var503:Array[Object]>*/;
2235 }
2236 }
2237 {
2238 var506 = ((val* (*)(val*))(var503->class->vft[COLOR_string__Object__to_s]))(var503) /* to_s on <var503:Array[Object]>*/;
2239 }
2240 {
2241 abstract_compiler__AbstractCompilerVisitor__add(self, var506); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
2242 }
2243 if (varonce507) {
2244 var508 = varonce507;
2245 } else {
2246 var509 = " = ";
2247 var510 = 3;
2248 var511 = string__NativeString__to_s_with_length(var509, var510);
2249 var508 = var511;
2250 varonce507 = var508;
2251 }
2252 if (varonce512) {
2253 var513 = varonce512;
2254 } else {
2255 var514 = ".class->id;";
2256 var515 = 11;
2257 var516 = string__NativeString__to_s_with_length(var514, var515);
2258 var513 = var516;
2259 varonce512 = var513;
2260 }
2261 var517 = NEW_array__Array(&type_array__Arraykernel__Object);
2262 { /* var517 = array_instance Array[Object] */
2263 var518 = 4;
2264 var519 = NEW_array__NativeArray(var518, &type_array__NativeArraykernel__Object);
2265 ((struct instance_array__NativeArray*)var519)->values[0] = (val*) var_idtype;
2266 ((struct instance_array__NativeArray*)var519)->values[1] = (val*) var508;
2267 ((struct instance_array__NativeArray*)var519)->values[2] = (val*) var_entry;
2268 ((struct instance_array__NativeArray*)var519)->values[3] = (val*) var513;
2269 {
2270 ((void (*)(val*, val*, long))(var517->class->vft[COLOR_array__Array__with_native]))(var517, var519, var518) /* with_native on <var517:Array[Object]>*/;
2271 }
2272 }
2273 {
2274 var520 = ((val* (*)(val*))(var517->class->vft[COLOR_string__Object__to_s]))(var517) /* to_s on <var517:Array[Object]>*/;
2275 }
2276 {
2277 abstract_compiler__AbstractCompilerVisitor__add(self, var520); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
2278 }
2279 var_522 = var_maybe_null;
2280 if (var_maybe_null){
2281 if (varonce523) {
2282 var524 = varonce523;
2283 } else {
2284 var525 = "0";
2285 var526 = 1;
2286 var527 = string__NativeString__to_s_with_length(var525, var526);
2287 var524 = var527;
2288 varonce523 = var524;
2289 }
2290 {
2291 var529 = string__FlatString___61d_61d(var_accept_null, var524);
2292 var528 = var529;
2293 }
2294 var521 = var528;
2295 } else {
2296 var521 = var_522;
2297 }
2298 if (var521){
2299 if (varonce530) {
2300 var531 = varonce530;
2301 } else {
2302 var532 = "is_nullable";
2303 var533 = 11;
2304 var534 = string__NativeString__to_s_with_length(var532, var533);
2305 var531 = var534;
2306 varonce530 = var531;
2307 }
2308 {
2309 var535 = abstract_compiler__AbstractCompilerVisitor__get_name(self, var531);
2310 }
2311 var_is_nullable = var535;
2312 if (varonce536) {
2313 var537 = varonce536;
2314 } else {
2315 var538 = "short int ";
2316 var539 = 10;
2317 var540 = string__NativeString__to_s_with_length(var538, var539);
2318 var537 = var540;
2319 varonce536 = var537;
2320 }
2321 if (varonce541) {
2322 var542 = varonce541;
2323 } else {
2324 var543 = ";";
2325 var544 = 1;
2326 var545 = string__NativeString__to_s_with_length(var543, var544);
2327 var542 = var545;
2328 varonce541 = var542;
2329 }
2330 var546 = NEW_array__Array(&type_array__Arraykernel__Object);
2331 { /* var546 = array_instance Array[Object] */
2332 var547 = 3;
2333 var548 = NEW_array__NativeArray(var547, &type_array__NativeArraykernel__Object);
2334 ((struct instance_array__NativeArray*)var548)->values[0] = (val*) var537;
2335 ((struct instance_array__NativeArray*)var548)->values[1] = (val*) var_is_nullable;
2336 ((struct instance_array__NativeArray*)var548)->values[2] = (val*) var542;
2337 {
2338 ((void (*)(val*, val*, long))(var546->class->vft[COLOR_array__Array__with_native]))(var546, var548, var547) /* with_native on <var546:Array[Object]>*/;
2339 }
2340 }
2341 {
2342 var549 = ((val* (*)(val*))(var546->class->vft[COLOR_string__Object__to_s]))(var546) /* to_s on <var546:Array[Object]>*/;
2343 }
2344 {
2345 abstract_compiler__AbstractCompilerVisitor__add_decl(self, var549); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on <self:SeparateErasureCompilerVisitor>*/
2346 }
2347 if (varonce550) {
2348 var551 = varonce550;
2349 } else {
2350 var552 = " = ";
2351 var553 = 3;
2352 var554 = string__NativeString__to_s_with_length(var552, var553);
2353 var551 = var554;
2354 varonce550 = var551;
2355 }
2356 if (varonce555) {
2357 var556 = varonce555;
2358 } else {
2359 var557 = ".is_nullable;";
2360 var558 = 13;
2361 var559 = string__NativeString__to_s_with_length(var557, var558);
2362 var556 = var559;
2363 varonce555 = var556;
2364 }
2365 var560 = NEW_array__Array(&type_array__Arraykernel__Object);
2366 { /* var560 = array_instance Array[Object] */
2367 var561 = 4;
2368 var562 = NEW_array__NativeArray(var561, &type_array__NativeArraykernel__Object);
2369 ((struct instance_array__NativeArray*)var562)->values[0] = (val*) var_is_nullable;
2370 ((struct instance_array__NativeArray*)var562)->values[1] = (val*) var551;
2371 ((struct instance_array__NativeArray*)var562)->values[2] = (val*) var_entry;
2372 ((struct instance_array__NativeArray*)var562)->values[3] = (val*) var556;
2373 {
2374 ((void (*)(val*, val*, long))(var560->class->vft[COLOR_array__Array__with_native]))(var560, var562, var561) /* with_native on <var560:Array[Object]>*/;
2375 }
2376 }
2377 {
2378 var563 = ((val* (*)(val*))(var560->class->vft[COLOR_string__Object__to_s]))(var560) /* to_s on <var560:Array[Object]>*/;
2379 }
2380 {
2381 abstract_compiler__AbstractCompilerVisitor__add(self, var563); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
2382 }
2383 {
2384 var564 = string__String__to_s(var_is_nullable);
2385 }
2386 var_accept_null = var564;
2387 } else {
2388 }
2389 {
2390 { /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on <self:SeparateErasureCompilerVisitor> */
2391 var567 = self->attrs[COLOR_abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on <self:SeparateErasureCompilerVisitor> */
2392 if (unlikely(var567 == NULL)) {
2393 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler");
2394 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 984);
2395 show_backtrace(1);
2396 }
2397 var565 = var567;
2398 RET_LABEL566:(void)0;
2399 }
2400 }
2401 {
2402 { /* Inline abstract_compiler#AbstractCompiler#modelbuilder (var565) on <var565:AbstractCompiler(SeparateCompiler)> */
2403 var570 = var565->attrs[COLOR_abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on <var565:AbstractCompiler(SeparateCompiler)> */
2404 if (unlikely(var570 == NULL)) {
2405 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder");
2406 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 443);
2407 show_backtrace(1);
2408 }
2409 var568 = var570;
2410 RET_LABEL569:(void)0;
2411 }
2412 }
2413 {
2414 { /* Inline modelbuilder#ModelBuilder#toolcontext (var568) on <var568:ModelBuilder> */
2415 var573 = var568->attrs[COLOR_modelbuilder__ModelBuilder___toolcontext].val; /* _toolcontext on <var568:ModelBuilder> */
2416 if (unlikely(var573 == NULL)) {
2417 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext");
2418 PRINT_ERROR(" (%s:%d)\n", "src/modelbuilder.nit", 101);
2419 show_backtrace(1);
2420 }
2421 var571 = var573;
2422 RET_LABEL572:(void)0;
2423 }
2424 }
2425 {
2426 { /* Inline abstract_compiler#ToolContext#opt_typing_test_metrics (var571) on <var571:ToolContext> */
2427 var576 = var571->attrs[COLOR_abstract_compiler__ToolContext___opt_typing_test_metrics].val; /* _opt_typing_test_metrics on <var571:ToolContext> */
2428 if (unlikely(var576 == NULL)) {
2429 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_typing_test_metrics");
2430 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 56);
2431 show_backtrace(1);
2432 }
2433 var574 = var576;
2434 RET_LABEL575:(void)0;
2435 }
2436 }
2437 {
2438 { /* Inline opts#Option#value (var574) on <var574:OptionBool> */
2439 var579 = var574->attrs[COLOR_opts__Option___value].val; /* _value on <var574:OptionBool> */
2440 var577 = var579;
2441 RET_LABEL578:(void)0;
2442 }
2443 }
2444 var580 = ((struct instance_kernel__Bool*)var577)->value; /* autounbox from nullable Object to Bool */;
2445 if (var580){
2446 {
2447 { /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on <self:SeparateErasureCompilerVisitor> */
2448 var583 = self->attrs[COLOR_abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on <self:SeparateErasureCompilerVisitor> */
2449 if (unlikely(var583 == NULL)) {
2450 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler");
2451 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 984);
2452 show_backtrace(1);
2453 }
2454 var581 = var583;
2455 RET_LABEL582:(void)0;
2456 }
2457 }
2458 {
2459 { /* Inline abstract_compiler#AbstractCompiler#count_type_test_unresolved (var581) on <var581:AbstractCompiler(SeparateCompiler)> */
2460 var586 = var581->attrs[COLOR_abstract_compiler__AbstractCompiler___count_type_test_unresolved].val; /* _count_type_test_unresolved on <var581:AbstractCompiler(SeparateCompiler)> */
2461 if (unlikely(var586 == NULL)) {
2462 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _count_type_test_unresolved");
2463 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 890);
2464 show_backtrace(1);
2465 }
2466 var584 = var586;
2467 RET_LABEL585:(void)0;
2468 }
2469 }
2470 var_587 = var584;
2471 var_588 = var_tag;
2472 {
2473 var589 = hash_collection__HashMap___91d_93d(var_587, var_588);
2474 }
2475 var590 = 1;
2476 {
2477 { /* Inline kernel#Int#+ (var589,var590) on <var589:nullable Object(Int)> */
2478 /* Covariant cast for argument 0 (i) <var590:Int> isa OTHER */
2479 /* <var590:Int> isa OTHER */
2480 var593 = 1; /* easy <var590:Int> isa OTHER*/
2481 if (unlikely(!var593)) {
2482 var_class_name596 = type_kernel__Int.name;
2483 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name596);
2484 PRINT_ERROR(" (%s:%d)\n", "lib/standard/kernel.nit", 328);
2485 show_backtrace(1);
2486 }
2487 var597 = ((struct instance_kernel__Int*)var589)->value; /* autounbox from nullable Object to Int */;
2488 var598 = var597 + var590;
2489 var591 = var598;
2490 goto RET_LABEL592;
2491 RET_LABEL592:(void)0;
2492 }
2493 }
2494 {
2495 var599 = BOX_kernel__Int(var591); /* autobox from Int to nullable Object */
2496 hash_collection__HashMap___91d_93d_61d(var_587, var_588, var599); /* Direct call hash_collection#HashMap#[]= on <var_587:HashMap[String, Int]>*/
2497 }
2498 if (varonce600) {
2499 var601 = varonce600;
2500 } else {
2501 var602 = "count_type_test_unresolved_";
2502 var603 = 27;
2503 var604 = string__NativeString__to_s_with_length(var602, var603);
2504 var601 = var604;
2505 varonce600 = var601;
2506 }
2507 if (varonce605) {
2508 var606 = varonce605;
2509 } else {
2510 var607 = "++;";
2511 var608 = 3;
2512 var609 = string__NativeString__to_s_with_length(var607, var608);
2513 var606 = var609;
2514 varonce605 = var606;
2515 }
2516 var610 = NEW_array__Array(&type_array__Arraykernel__Object);
2517 { /* var610 = array_instance Array[Object] */
2518 var611 = 3;
2519 var612 = NEW_array__NativeArray(var611, &type_array__NativeArraykernel__Object);
2520 ((struct instance_array__NativeArray*)var612)->values[0] = (val*) var601;
2521 ((struct instance_array__NativeArray*)var612)->values[1] = (val*) var_tag;
2522 ((struct instance_array__NativeArray*)var612)->values[2] = (val*) var606;
2523 {
2524 ((void (*)(val*, val*, long))(var610->class->vft[COLOR_array__Array__with_native]))(var610, var612, var611) /* with_native on <var610:Array[Object]>*/;
2525 }
2526 }
2527 {
2528 var613 = ((val* (*)(val*))(var610->class->vft[COLOR_string__Object__to_s]))(var610) /* to_s on <var610:Array[Object]>*/;
2529 }
2530 {
2531 abstract_compiler__AbstractCompilerVisitor__add(self, var613); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
2532 }
2533 } else {
2534 }
2535 } else {
2536 if (varonce614) {
2537 var615 = varonce614;
2538 } else {
2539 var616 = "type_test(";
2540 var617 = 10;
2541 var618 = string__NativeString__to_s_with_length(var616, var617);
2542 var615 = var618;
2543 varonce614 = var615;
2544 }
2545 {
2546 var619 = abstract_compiler__RuntimeVariable__inspect(var_value);
2547 }
2548 if (varonce620) {
2549 var621 = varonce620;
2550 } else {
2551 var622 = ", ";
2552 var623 = 2;
2553 var624 = string__NativeString__to_s_with_length(var622, var623);
2554 var621 = var624;
2555 varonce620 = var621;
2556 }
2557 if (varonce625) {
2558 var626 = varonce625;
2559 } else {
2560 var627 = ")";
2561 var628 = 1;
2562 var629 = string__NativeString__to_s_with_length(var627, var628);
2563 var626 = var629;
2564 varonce625 = var626;
2565 }
2566 var630 = NEW_array__Array(&type_array__Arraykernel__Object);
2567 { /* var630 = array_instance Array[Object] */
2568 var631 = 5;
2569 var632 = NEW_array__NativeArray(var631, &type_array__NativeArraykernel__Object);
2570 ((struct instance_array__NativeArray*)var632)->values[0] = (val*) var615;
2571 ((struct instance_array__NativeArray*)var632)->values[1] = (val*) var619;
2572 ((struct instance_array__NativeArray*)var632)->values[2] = (val*) var621;
2573 ((struct instance_array__NativeArray*)var632)->values[3] = (val*) var_mtype;
2574 ((struct instance_array__NativeArray*)var632)->values[4] = (val*) var626;
2575 {
2576 ((void (*)(val*, val*, long))(var630->class->vft[COLOR_array__Array__with_native]))(var630, var632, var631) /* with_native on <var630:Array[Object]>*/;
2577 }
2578 }
2579 {
2580 var633 = ((val* (*)(val*))(var630->class->vft[COLOR_string__Object__to_s]))(var630) /* to_s on <var630:Array[Object]>*/;
2581 }
2582 {
2583 abstract_compiler__AbstractCompilerVisitor__debug(self, var633); /* Direct call abstract_compiler#AbstractCompilerVisitor#debug on <self:SeparateErasureCompilerVisitor>*/
2584 }
2585 PRINT_ERROR("Runtime error: %s", "Aborted");
2586 PRINT_ERROR(" (%s:%d)\n", "src/separate_erasure_compiler.nit", 551);
2587 show_backtrace(1);
2588 }
2589 }
2590 if (var_maybe_null){
2591 if (varonce634) {
2592 var635 = varonce634;
2593 } else {
2594 var636 = "if(";
2595 var637 = 3;
2596 var638 = string__NativeString__to_s_with_length(var636, var637);
2597 var635 = var638;
2598 varonce634 = var635;
2599 }
2600 if (varonce639) {
2601 var640 = varonce639;
2602 } else {
2603 var641 = " == NULL) {";
2604 var642 = 11;
2605 var643 = string__NativeString__to_s_with_length(var641, var642);
2606 var640 = var643;
2607 varonce639 = var640;
2608 }
2609 var644 = NEW_array__Array(&type_array__Arraykernel__Object);
2610 { /* var644 = array_instance Array[Object] */
2611 var645 = 3;
2612 var646 = NEW_array__NativeArray(var645, &type_array__NativeArraykernel__Object);
2613 ((struct instance_array__NativeArray*)var646)->values[0] = (val*) var635;
2614 ((struct instance_array__NativeArray*)var646)->values[1] = (val*) var_value;
2615 ((struct instance_array__NativeArray*)var646)->values[2] = (val*) var640;
2616 {
2617 ((void (*)(val*, val*, long))(var644->class->vft[COLOR_array__Array__with_native]))(var644, var646, var645) /* with_native on <var644:Array[Object]>*/;
2618 }
2619 }
2620 {
2621 var647 = ((val* (*)(val*))(var644->class->vft[COLOR_string__Object__to_s]))(var644) /* to_s on <var644:Array[Object]>*/;
2622 }
2623 {
2624 abstract_compiler__AbstractCompilerVisitor__add(self, var647); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
2625 }
2626 if (varonce648) {
2627 var649 = varonce648;
2628 } else {
2629 var650 = " = ";
2630 var651 = 3;
2631 var652 = string__NativeString__to_s_with_length(var650, var651);
2632 var649 = var652;
2633 varonce648 = var649;
2634 }
2635 if (varonce653) {
2636 var654 = varonce653;
2637 } else {
2638 var655 = ";";
2639 var656 = 1;
2640 var657 = string__NativeString__to_s_with_length(var655, var656);
2641 var654 = var657;
2642 varonce653 = var654;
2643 }
2644 var658 = NEW_array__Array(&type_array__Arraykernel__Object);
2645 { /* var658 = array_instance Array[Object] */
2646 var659 = 4;
2647 var660 = NEW_array__NativeArray(var659, &type_array__NativeArraykernel__Object);
2648 ((struct instance_array__NativeArray*)var660)->values[0] = (val*) var_res;
2649 ((struct instance_array__NativeArray*)var660)->values[1] = (val*) var649;
2650 ((struct instance_array__NativeArray*)var660)->values[2] = (val*) var_accept_null;
2651 ((struct instance_array__NativeArray*)var660)->values[3] = (val*) var654;
2652 {
2653 ((void (*)(val*, val*, long))(var658->class->vft[COLOR_array__Array__with_native]))(var658, var660, var659) /* with_native on <var658:Array[Object]>*/;
2654 }
2655 }
2656 {
2657 var661 = ((val* (*)(val*))(var658->class->vft[COLOR_string__Object__to_s]))(var658) /* to_s on <var658:Array[Object]>*/;
2658 }
2659 {
2660 abstract_compiler__AbstractCompilerVisitor__add(self, var661); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
2661 }
2662 if (varonce662) {
2663 var663 = varonce662;
2664 } else {
2665 var664 = "} else {";
2666 var665 = 8;
2667 var666 = string__NativeString__to_s_with_length(var664, var665);
2668 var663 = var666;
2669 varonce662 = var663;
2670 }
2671 {
2672 abstract_compiler__AbstractCompilerVisitor__add(self, var663); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
2673 }
2674 } else {
2675 }
2676 if (varonce667) {
2677 var668 = varonce667;
2678 } else {
2679 var669 = "if(";
2680 var670 = 3;
2681 var671 = string__NativeString__to_s_with_length(var669, var670);
2682 var668 = var671;
2683 varonce667 = var668;
2684 }
2685 if (varonce672) {
2686 var673 = varonce672;
2687 } else {
2688 var674 = " >= ";
2689 var675 = 4;
2690 var676 = string__NativeString__to_s_with_length(var674, var675);
2691 var673 = var676;
2692 varonce672 = var673;
2693 }
2694 if (varonce677) {
2695 var678 = varonce677;
2696 } else {
2697 var679 = "type_table->size) {";
2698 var680 = 19;
2699 var681 = string__NativeString__to_s_with_length(var679, var680);
2700 var678 = var681;
2701 varonce677 = var678;
2702 }
2703 var682 = NEW_array__Array(&type_array__Arraykernel__Object);
2704 { /* var682 = array_instance Array[Object] */
2705 var683 = 5;
2706 var684 = NEW_array__NativeArray(var683, &type_array__NativeArraykernel__Object);
2707 ((struct instance_array__NativeArray*)var684)->values[0] = (val*) var668;
2708 ((struct instance_array__NativeArray*)var684)->values[1] = (val*) var_cltype;
2709 ((struct instance_array__NativeArray*)var684)->values[2] = (val*) var673;
2710 ((struct instance_array__NativeArray*)var684)->values[3] = (val*) var_class_ptr;
2711 ((struct instance_array__NativeArray*)var684)->values[4] = (val*) var678;
2712 {
2713 ((void (*)(val*, val*, long))(var682->class->vft[COLOR_array__Array__with_native]))(var682, var684, var683) /* with_native on <var682:Array[Object]>*/;
2714 }
2715 }
2716 {
2717 var685 = ((val* (*)(val*))(var682->class->vft[COLOR_string__Object__to_s]))(var682) /* to_s on <var682:Array[Object]>*/;
2718 }
2719 {
2720 abstract_compiler__AbstractCompilerVisitor__add(self, var685); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
2721 }
2722 if (varonce686) {
2723 var687 = varonce686;
2724 } else {
2725 var688 = " = 0;";
2726 var689 = 5;
2727 var690 = string__NativeString__to_s_with_length(var688, var689);
2728 var687 = var690;
2729 varonce686 = var687;
2730 }
2731 var691 = NEW_array__Array(&type_array__Arraykernel__Object);
2732 { /* var691 = array_instance Array[Object] */
2733 var692 = 2;
2734 var693 = NEW_array__NativeArray(var692, &type_array__NativeArraykernel__Object);
2735 ((struct instance_array__NativeArray*)var693)->values[0] = (val*) var_res;
2736 ((struct instance_array__NativeArray*)var693)->values[1] = (val*) var687;
2737 {
2738 ((void (*)(val*, val*, long))(var691->class->vft[COLOR_array__Array__with_native]))(var691, var693, var692) /* with_native on <var691:Array[Object]>*/;
2739 }
2740 }
2741 {
2742 var694 = ((val* (*)(val*))(var691->class->vft[COLOR_string__Object__to_s]))(var691) /* to_s on <var691:Array[Object]>*/;
2743 }
2744 {
2745 abstract_compiler__AbstractCompilerVisitor__add(self, var694); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
2746 }
2747 if (varonce695) {
2748 var696 = varonce695;
2749 } else {
2750 var697 = "} else {";
2751 var698 = 8;
2752 var699 = string__NativeString__to_s_with_length(var697, var698);
2753 var696 = var699;
2754 varonce695 = var696;
2755 }
2756 {
2757 abstract_compiler__AbstractCompilerVisitor__add(self, var696); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
2758 }
2759 if (varonce700) {
2760 var701 = varonce700;
2761 } else {
2762 var702 = " = ";
2763 var703 = 3;
2764 var704 = string__NativeString__to_s_with_length(var702, var703);
2765 var701 = var704;
2766 varonce700 = var701;
2767 }
2768 if (varonce705) {
2769 var706 = varonce705;
2770 } else {
2771 var707 = "type_table->table[";
2772 var708 = 18;
2773 var709 = string__NativeString__to_s_with_length(var707, var708);
2774 var706 = var709;
2775 varonce705 = var706;
2776 }
2777 if (varonce710) {
2778 var711 = varonce710;
2779 } else {
2780 var712 = "] == ";
2781 var713 = 5;
2782 var714 = string__NativeString__to_s_with_length(var712, var713);
2783 var711 = var714;
2784 varonce710 = var711;
2785 }
2786 if (varonce715) {
2787 var716 = varonce715;
2788 } else {
2789 var717 = ";";
2790 var718 = 1;
2791 var719 = string__NativeString__to_s_with_length(var717, var718);
2792 var716 = var719;
2793 varonce715 = var716;
2794 }
2795 var720 = NEW_array__Array(&type_array__Arraykernel__Object);
2796 { /* var720 = array_instance Array[Object] */
2797 var721 = 8;
2798 var722 = NEW_array__NativeArray(var721, &type_array__NativeArraykernel__Object);
2799 ((struct instance_array__NativeArray*)var722)->values[0] = (val*) var_res;
2800 ((struct instance_array__NativeArray*)var722)->values[1] = (val*) var701;
2801 ((struct instance_array__NativeArray*)var722)->values[2] = (val*) var_class_ptr;
2802 ((struct instance_array__NativeArray*)var722)->values[3] = (val*) var706;
2803 ((struct instance_array__NativeArray*)var722)->values[4] = (val*) var_cltype;
2804 ((struct instance_array__NativeArray*)var722)->values[5] = (val*) var711;
2805 ((struct instance_array__NativeArray*)var722)->values[6] = (val*) var_idtype;
2806 ((struct instance_array__NativeArray*)var722)->values[7] = (val*) var716;
2807 {
2808 ((void (*)(val*, val*, long))(var720->class->vft[COLOR_array__Array__with_native]))(var720, var722, var721) /* with_native on <var720:Array[Object]>*/;
2809 }
2810 }
2811 {
2812 var723 = ((val* (*)(val*))(var720->class->vft[COLOR_string__Object__to_s]))(var720) /* to_s on <var720:Array[Object]>*/;
2813 }
2814 {
2815 abstract_compiler__AbstractCompilerVisitor__add(self, var723); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
2816 }
2817 if (varonce724) {
2818 var725 = varonce724;
2819 } else {
2820 var726 = "}";
2821 var727 = 1;
2822 var728 = string__NativeString__to_s_with_length(var726, var727);
2823 var725 = var728;
2824 varonce724 = var725;
2825 }
2826 {
2827 abstract_compiler__AbstractCompilerVisitor__add(self, var725); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
2828 }
2829 if (var_maybe_null){
2830 if (varonce729) {
2831 var730 = varonce729;
2832 } else {
2833 var731 = "}";
2834 var732 = 1;
2835 var733 = string__NativeString__to_s_with_length(var731, var732);
2836 var730 = var733;
2837 varonce729 = var730;
2838 }
2839 {
2840 abstract_compiler__AbstractCompilerVisitor__add(self, var730); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
2841 }
2842 } else {
2843 }
2844 var = var_res;
2845 goto RET_LABEL;
2846 RET_LABEL:;
2847 return var;
2848 }
2849 /* method separate_erasure_compiler#SeparateErasureCompilerVisitor#type_test for (self: Object, RuntimeVariable, MType, String): RuntimeVariable */
2850 val* VIRTUAL_separate_erasure_compiler__SeparateErasureCompilerVisitor__type_test(val* self, val* p0, val* p1, val* p2) {
2851 val* var /* : RuntimeVariable */;
2852 val* var1 /* : RuntimeVariable */;
2853 var1 = separate_erasure_compiler__SeparateErasureCompilerVisitor__type_test(self, p0, p1, p2);
2854 var = var1;
2855 RET_LABEL:;
2856 return var;
2857 }
2858 /* method separate_erasure_compiler#SeparateErasureCompilerVisitor#class_name_string for (self: SeparateErasureCompilerVisitor, RuntimeVariable): String */
2859 val* separate_erasure_compiler__SeparateErasureCompilerVisitor__class_name_string(val* self, val* p0) {
2860 val* var /* : String */;
2861 val* var_value /* var value: RuntimeVariable */;
2862 static val* varonce;
2863 val* var1 /* : String */;
2864 char* var2 /* : NativeString */;
2865 long var3 /* : Int */;
2866 val* var4 /* : FlatString */;
2867 val* var5 /* : String */;
2868 val* var_res /* var res: String */;
2869 static val* varonce6;
2870 val* var7 /* : String */;
2871 char* var8 /* : NativeString */;
2872 long var9 /* : Int */;
2873 val* var10 /* : FlatString */;
2874 static val* varonce11;
2875 val* var12 /* : String */;
2876 char* var13 /* : NativeString */;
2877 long var14 /* : Int */;
2878 val* var15 /* : FlatString */;
2879 val* var16 /* : Array[Object] */;
2880 long var17 /* : Int */;
2881 val* var18 /* : NativeArray[Object] */;
2882 val* var19 /* : String */;
2883 val* var20 /* : MType */;
2884 val* var22 /* : MType */;
2885 val* var23 /* : String */;
2886 static val* varonce24;
2887 val* var25 /* : String */;
2888 char* var26 /* : NativeString */;
2889 long var27 /* : Int */;
2890 val* var28 /* : FlatString */;
2891 short int var29 /* : Bool */;
2892 short int var30 /* : Bool */;
2893 static val* varonce31;
2894 val* var32 /* : String */;
2895 char* var33 /* : NativeString */;
2896 long var34 /* : Int */;
2897 val* var35 /* : FlatString */;
2898 static val* varonce36;
2899 val* var37 /* : String */;
2900 char* var38 /* : NativeString */;
2901 long var39 /* : Int */;
2902 val* var40 /* : FlatString */;
2903 static val* varonce41;
2904 val* var42 /* : String */;
2905 char* var43 /* : NativeString */;
2906 long var44 /* : Int */;
2907 val* var45 /* : FlatString */;
2908 val* var46 /* : Array[Object] */;
2909 long var47 /* : Int */;
2910 val* var48 /* : NativeArray[Object] */;
2911 val* var49 /* : String */;
2912 static val* varonce50;
2913 val* var51 /* : String */;
2914 char* var52 /* : NativeString */;
2915 long var53 /* : Int */;
2916 val* var54 /* : FlatString */;
2917 val* var55 /* : MType */;
2918 val* var57 /* : MType */;
2919 val* var58 /* : String */;
2920 val* var59 /* : Array[Object] */;
2921 long var60 /* : Int */;
2922 val* var61 /* : NativeArray[Object] */;
2923 val* var62 /* : String */;
2924 static val* varonce63;
2925 val* var64 /* : String */;
2926 char* var65 /* : NativeString */;
2927 long var66 /* : Int */;
2928 val* var67 /* : FlatString */;
2929 val* var68 /* : MType */;
2930 val* var70 /* : MType */;
2931 val* var71 /* : String */;
2932 static val* varonce72;
2933 val* var73 /* : String */;
2934 char* var74 /* : NativeString */;
2935 long var75 /* : Int */;
2936 val* var76 /* : FlatString */;
2937 val* var77 /* : Array[Object] */;
2938 long var78 /* : Int */;
2939 val* var79 /* : NativeArray[Object] */;
2940 val* var80 /* : String */;
2941 var_value = p0;
2942 if (varonce) {
2943 var1 = varonce;
2944 } else {
2945 var2 = "var_class_name";
2946 var3 = 14;
2947 var4 = string__NativeString__to_s_with_length(var2, var3);
2948 var1 = var4;
2949 varonce = var1;
2950 }
2951 {
2952 var5 = abstract_compiler__AbstractCompilerVisitor__get_name(self, var1);
2953 }
2954 var_res = var5;
2955 if (varonce6) {
2956 var7 = varonce6;
2957 } else {
2958 var8 = "const char* ";
2959 var9 = 12;
2960 var10 = string__NativeString__to_s_with_length(var8, var9);
2961 var7 = var10;
2962 varonce6 = var7;
2963 }
2964 if (varonce11) {
2965 var12 = varonce11;
2966 } else {
2967 var13 = ";";
2968 var14 = 1;
2969 var15 = string__NativeString__to_s_with_length(var13, var14);
2970 var12 = var15;
2971 varonce11 = var12;
2972 }
2973 var16 = NEW_array__Array(&type_array__Arraykernel__Object);
2974 { /* var16 = array_instance Array[Object] */
2975 var17 = 3;
2976 var18 = NEW_array__NativeArray(var17, &type_array__NativeArraykernel__Object);
2977 ((struct instance_array__NativeArray*)var18)->values[0] = (val*) var7;
2978 ((struct instance_array__NativeArray*)var18)->values[1] = (val*) var_res;
2979 ((struct instance_array__NativeArray*)var18)->values[2] = (val*) var12;
2980 {
2981 ((void (*)(val*, val*, long))(var16->class->vft[COLOR_array__Array__with_native]))(var16, var18, var17) /* with_native on <var16:Array[Object]>*/;
2982 }
2983 }
2984 {
2985 var19 = ((val* (*)(val*))(var16->class->vft[COLOR_string__Object__to_s]))(var16) /* to_s on <var16:Array[Object]>*/;
2986 }
2987 {
2988 abstract_compiler__AbstractCompilerVisitor__add_decl(self, var19); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on <self:SeparateErasureCompilerVisitor>*/
2989 }
2990 {
2991 { /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on <var_value:RuntimeVariable> */
2992 var22 = var_value->attrs[COLOR_abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on <var_value:RuntimeVariable> */
2993 if (unlikely(var22 == NULL)) {
2994 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype");
2995 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 1484);
2996 show_backtrace(1);
2997 }
2998 var20 = var22;
2999 RET_LABEL21:(void)0;
3000 }
3001 }
3002 {
3003 var23 = ((val* (*)(val*))(var20->class->vft[COLOR_abstract_compiler__MType__ctype]))(var20) /* ctype on <var20:MType>*/;
3004 }
3005 if (varonce24) {
3006 var25 = varonce24;
3007 } else {
3008 var26 = "val*";
3009 var27 = 4;
3010 var28 = string__NativeString__to_s_with_length(var26, var27);
3011 var25 = var28;
3012 varonce24 = var25;
3013 }
3014 {
3015 var30 = string__FlatString___61d_61d(var23, var25);
3016 var29 = var30;
3017 }
3018 if (var29){
3019 if (varonce31) {
3020 var32 = varonce31;
3021 } else {
3022 var33 = " = ";
3023 var34 = 3;
3024 var35 = string__NativeString__to_s_with_length(var33, var34);
3025 var32 = var35;
3026 varonce31 = var32;
3027 }
3028 if (varonce36) {
3029 var37 = varonce36;
3030 } else {
3031 var38 = " == NULL ? \"null\" : ";
3032 var39 = 20;
3033 var40 = string__NativeString__to_s_with_length(var38, var39);
3034 var37 = var40;
3035 varonce36 = var37;
3036 }
3037 if (varonce41) {
3038 var42 = varonce41;
3039 } else {
3040 var43 = "->class->name;";
3041 var44 = 14;
3042 var45 = string__NativeString__to_s_with_length(var43, var44);
3043 var42 = var45;
3044 varonce41 = var42;
3045 }
3046 var46 = NEW_array__Array(&type_array__Arraykernel__Object);
3047 { /* var46 = array_instance Array[Object] */
3048 var47 = 6;
3049 var48 = NEW_array__NativeArray(var47, &type_array__NativeArraykernel__Object);
3050 ((struct instance_array__NativeArray*)var48)->values[0] = (val*) var_res;
3051 ((struct instance_array__NativeArray*)var48)->values[1] = (val*) var32;
3052 ((struct instance_array__NativeArray*)var48)->values[2] = (val*) var_value;
3053 ((struct instance_array__NativeArray*)var48)->values[3] = (val*) var37;
3054 ((struct instance_array__NativeArray*)var48)->values[4] = (val*) var_value;
3055 ((struct instance_array__NativeArray*)var48)->values[5] = (val*) var42;
3056 {
3057 ((void (*)(val*, val*, long))(var46->class->vft[COLOR_array__Array__with_native]))(var46, var48, var47) /* with_native on <var46:Array[Object]>*/;
3058 }
3059 }
3060 {
3061 var49 = ((val* (*)(val*))(var46->class->vft[COLOR_string__Object__to_s]))(var46) /* to_s on <var46:Array[Object]>*/;
3062 }
3063 {
3064 abstract_compiler__AbstractCompilerVisitor__add(self, var49); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
3065 }
3066 } else {
3067 if (varonce50) {
3068 var51 = varonce50;
3069 } else {
3070 var52 = "class_";
3071 var53 = 6;
3072 var54 = string__NativeString__to_s_with_length(var52, var53);
3073 var51 = var54;
3074 varonce50 = var51;
3075 }
3076 {
3077 { /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on <var_value:RuntimeVariable> */
3078 var57 = var_value->attrs[COLOR_abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on <var_value:RuntimeVariable> */
3079 if (unlikely(var57 == NULL)) {
3080 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype");
3081 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 1484);
3082 show_backtrace(1);
3083 }
3084 var55 = var57;
3085 RET_LABEL56:(void)0;
3086 }
3087 }
3088 {
3089 var58 = ((val* (*)(val*))(var55->class->vft[COLOR_abstract_compiler__MType__c_name]))(var55) /* c_name on <var55:MType>*/;
3090 }
3091 var59 = NEW_array__Array(&type_array__Arraykernel__Object);
3092 { /* var59 = array_instance Array[Object] */
3093 var60 = 2;
3094 var61 = NEW_array__NativeArray(var60, &type_array__NativeArraykernel__Object);
3095 ((struct instance_array__NativeArray*)var61)->values[0] = (val*) var51;
3096 ((struct instance_array__NativeArray*)var61)->values[1] = (val*) var58;
3097 {
3098 ((void (*)(val*, val*, long))(var59->class->vft[COLOR_array__Array__with_native]))(var59, var61, var60) /* with_native on <var59:Array[Object]>*/;
3099 }
3100 }
3101 {
3102 var62 = ((val* (*)(val*))(var59->class->vft[COLOR_string__Object__to_s]))(var59) /* to_s on <var59:Array[Object]>*/;
3103 }
3104 {
3105 abstract_compiler__AbstractCompilerVisitor__require_declaration(self, var62); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on <self:SeparateErasureCompilerVisitor>*/
3106 }
3107 if (varonce63) {
3108 var64 = varonce63;
3109 } else {
3110 var65 = " = class_";
3111 var66 = 9;
3112 var67 = string__NativeString__to_s_with_length(var65, var66);
3113 var64 = var67;
3114 varonce63 = var64;
3115 }
3116 {
3117 { /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on <var_value:RuntimeVariable> */
3118 var70 = var_value->attrs[COLOR_abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on <var_value:RuntimeVariable> */
3119 if (unlikely(var70 == NULL)) {
3120 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype");
3121 PRINT_ERROR(" (%s:%d)\n", "src/abstract_compiler.nit", 1484);
3122 show_backtrace(1);
3123 }
3124 var68 = var70;
3125 RET_LABEL69:(void)0;
3126 }
3127 }
3128 {
3129 var71 = ((val* (*)(val*))(var68->class->vft[COLOR_abstract_compiler__MType__c_name]))(var68) /* c_name on <var68:MType>*/;
3130 }
3131 if (varonce72) {
3132 var73 = varonce72;
3133 } else {
3134 var74 = ".name;";
3135 var75 = 6;
3136 var76 = string__NativeString__to_s_with_length(var74, var75);
3137 var73 = var76;
3138 varonce72 = var73;
3139 }
3140 var77 = NEW_array__Array(&type_array__Arraykernel__Object);
3141 { /* var77 = array_instance Array[Object] */
3142 var78 = 4;
3143 var79 = NEW_array__NativeArray(var78, &type_array__NativeArraykernel__Object);
3144 ((struct instance_array__NativeArray*)var79)->values[0] = (val*) var_res;
3145 ((struct instance_array__NativeArray*)var79)->values[1] = (val*) var64;
3146 ((struct instance_array__NativeArray*)var79)->values[2] = (val*) var71;
3147 ((struct instance_array__NativeArray*)var79)->values[3] = (val*) var73;
3148 {
3149 ((void (*)(val*, val*, long))(var77->class->vft[COLOR_array__Array__with_native]))(var77, var79, var78) /* with_native on <var77:Array[Object]>*/;
3150 }
3151 }
3152 {
3153 var80 = ((val* (*)(val*))(var77->class->vft[COLOR_string__Object__to_s]))(var77) /* to_s on <var77:Array[Object]>*/;
3154 }
3155 {
3156 abstract_compiler__AbstractCompilerVisitor__add(self, var80); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
3157 }
3158 }
3159 var = var_res;
3160 goto RET_LABEL;
3161 RET_LABEL:;
3162 return var;
3163 }
3164 /* method separate_erasure_compiler#SeparateErasureCompilerVisitor#class_name_string for (self: Object, RuntimeVariable): String */
3165 val* VIRTUAL_separate_erasure_compiler__SeparateErasureCompilerVisitor__class_name_string(val* self, val* p0) {
3166 val* var /* : String */;
3167 val* var1 /* : String */;
3168 var1 = separate_erasure_compiler__SeparateErasureCompilerVisitor__class_name_string(self, p0);
3169 var = var1;
3170 RET_LABEL:;
3171 return var;
3172 }
3173 /* method separate_erasure_compiler#SeparateErasureCompilerVisitor#native_array_instance for (self: SeparateErasureCompilerVisitor, MType, RuntimeVariable): RuntimeVariable */
3174 val* separate_erasure_compiler__SeparateErasureCompilerVisitor__native_array_instance(val* self, val* p0, val* p1) {
3175 val* var /* : RuntimeVariable */;
3176 val* var_elttype /* var elttype: MType */;
3177 val* var_length /* var length: RuntimeVariable */;
3178 static val* varonce;
3179 val* var1 /* : String */;
3180 char* var2 /* : NativeString */;
3181 long var3 /* : Int */;
3182 val* var4 /* : FlatString */;
3183 val* var5 /* : MClass */;
3184 val* var_nclass /* var nclass: MClass */;
3185 val* var6 /* : Array[MType] */;
3186 long var7 /* : Int */;
3187 val* var_ /* var : Array[MType] */;
3188 val* var8 /* : MClassType */;
3189 val* var_mtype /* var mtype: MClassType */;
3190 val* var9 /* : RuntimeVariable */;
3191 val* var_res /* var res: RuntimeVariable */;
3192 short int var10 /* : Bool */;
3193 static val* varonce12;
3194 val* var13 /* : String */;
3195 char* var14 /* : NativeString */;
3196 long var15 /* : Int */;
3197 val* var16 /* : FlatString */;
3198 val* var17 /* : String */;
3199 val* var18 /* : Array[Object] */;
3200 long var19 /* : Int */;
3201 val* var20 /* : NativeArray[Object] */;
3202 val* var21 /* : String */;
3203 static val* varonce22;
3204 val* var23 /* : String */;
3205 char* var24 /* : NativeString */;
3206 long var25 /* : Int */;
3207 val* var26 /* : FlatString */;
3208 val* var27 /* : String */;
3209 static val* varonce28;
3210 val* var29 /* : String */;
3211 char* var30 /* : NativeString */;
3212 long var31 /* : Int */;
3213 val* var32 /* : FlatString */;
3214 static val* varonce33;
3215 val* var34 /* : String */;
3216 char* var35 /* : NativeString */;
3217 long var36 /* : Int */;
3218 val* var37 /* : FlatString */;
3219 val* var38 /* : Array[Object] */;
3220 long var39 /* : Int */;
3221 val* var40 /* : NativeArray[Object] */;
3222 val* var41 /* : String */;
3223 var_elttype = p0;
3224 var_length = p1;
3225 if (varonce) {
3226 var1 = varonce;
3227 } else {
3228 var2 = "NativeArray";
3229 var3 = 11;
3230 var4 = string__NativeString__to_s_with_length(var2, var3);
3231 var1 = var4;
3232 varonce = var1;
3233 }
3234 {
3235 var5 = abstract_compiler__AbstractCompilerVisitor__get_class(self, var1);
3236 }
3237 var_nclass = var5;
3238 var6 = NEW_array__Array(&type_array__Arraymodel__MType);
3239 var7 = 1;
3240 {
3241 array__Array__with_capacity(var6, var7); /* Direct call array#Array#with_capacity on <var6:Array[MType]>*/
3242 }
3243 var_ = var6;
3244 {
3245 array__AbstractArray__push(var_, var_elttype); /* Direct call array#AbstractArray#push on <var_:Array[MType]>*/
3246 }
3247 {
3248 var8 = model__MClass__get_mtype(var_nclass, var_);
3249 }
3250 var_mtype = var8;
3251 {
3252 var9 = abstract_compiler__AbstractCompilerVisitor__new_var(self, var_mtype);
3253 }
3254 var_res = var9;
3255 var10 = 1;
3256 {
3257 { /* Inline abstract_compiler#RuntimeVariable#is_exact= (var_res,var10) on <var_res:RuntimeVariable> */
3258 var_res->attrs[COLOR_abstract_compiler__RuntimeVariable___is_exact].s = var10; /* _is_exact on <var_res:RuntimeVariable> */
3259 RET_LABEL11:(void)0;
3260 }
3261 }
3262 if (varonce12) {
3263 var13 = varonce12;
3264 } else {
3265 var14 = "NEW_";
3266 var15 = 4;
3267 var16 = string__NativeString__to_s_with_length(var14, var15);
3268 var13 = var16;
3269 varonce12 = var13;
3270 }
3271 {
3272 var17 = abstract_compiler__MClass__c_name(var_nclass);
3273 }
3274 var18 = NEW_array__Array(&type_array__Arraykernel__Object);
3275 { /* var18 = array_instance Array[Object] */
3276 var19 = 2;
3277 var20 = NEW_array__NativeArray(var19, &type_array__NativeArraykernel__Object);
3278 ((struct instance_array__NativeArray*)var20)->values[0] = (val*) var13;
3279 ((struct instance_array__NativeArray*)var20)->values[1] = (val*) var17;
3280 {
3281 ((void (*)(val*, val*, long))(var18->class->vft[COLOR_array__Array__with_native]))(var18, var20, var19) /* with_native on <var18:Array[Object]>*/;
3282 }
3283 }
3284 {
3285 var21 = ((val* (*)(val*))(var18->class->vft[COLOR_string__Object__to_s]))(var18) /* to_s on <var18:Array[Object]>*/;
3286 }
3287 {
3288 abstract_compiler__AbstractCompilerVisitor__require_declaration(self, var21); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on <self:SeparateErasureCompilerVisitor>*/
3289 }
3290 if (varonce22) {
3291 var23 = varonce22;
3292 } else {
3293 var24 = " = NEW_";
3294 var25 = 7;
3295 var26 = string__NativeString__to_s_with_length(var24, var25);
3296 var23 = var26;
3297 varonce22 = var23;
3298 }
3299 {
3300 var27 = abstract_compiler__MClass__c_name(var_nclass);
3301 }
3302 if (varonce28) {
3303 var29 = varonce28;
3304 } else {
3305 var30 = "(";
3306 var31 = 1;
3307 var32 = string__NativeString__to_s_with_length(var30, var31);
3308 var29 = var32;
3309 varonce28 = var29;
3310 }
3311 if (varonce33) {
3312 var34 = varonce33;
3313 } else {
3314 var35 = ");";
3315 var36 = 2;
3316 var37 = string__NativeString__to_s_with_length(var35, var36);
3317 var34 = var37;
3318 varonce33 = var34;
3319 }
3320 var38 = NEW_array__Array(&type_array__Arraykernel__Object);
3321 { /* var38 = array_instance Array[Object] */
3322 var39 = 6;
3323 var40 = NEW_array__NativeArray(var39, &type_array__NativeArraykernel__Object);
3324 ((struct instance_array__NativeArray*)var40)->values[0] = (val*) var_res;
3325 ((struct instance_array__NativeArray*)var40)->values[1] = (val*) var23;
3326 ((struct instance_array__NativeArray*)var40)->values[2] = (val*) var27;
3327 ((struct instance_array__NativeArray*)var40)->values[3] = (val*) var29;
3328 ((struct instance_array__NativeArray*)var40)->values[4] = (val*) var_length;
3329 ((struct instance_array__NativeArray*)var40)->values[5] = (val*) var34;
3330 {
3331 ((void (*)(val*, val*, long))(var38->class->vft[COLOR_array__Array__with_native]))(var38, var40, var39) /* with_native on <var38:Array[Object]>*/;
3332 }
3333 }
3334 {
3335 var41 = ((val* (*)(val*))(var38->class->vft[COLOR_string__Object__to_s]))(var38) /* to_s on <var38:Array[Object]>*/;
3336 }
3337 {
3338 abstract_compiler__AbstractCompilerVisitor__add(self, var41); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on <self:SeparateErasureCompilerVisitor>*/
3339 }
3340 var = var_res;
3341 goto RET_LABEL;
3342 RET_LABEL:;
3343 return var;
3344 }
3345 /* method separate_erasure_compiler#SeparateErasureCompilerVisitor#native_array_instance for (self: Object, MType, RuntimeVariable): RuntimeVariable */
3346 val* VIRTUAL_separate_erasure_compiler__SeparateErasureCompilerVisitor__native_array_instance(val* self, val* p0, val* p1) {
3347 val* var /* : RuntimeVariable */;
3348 val* var1 /* : RuntimeVariable */;
3349 var1 = separate_erasure_compiler__SeparateErasureCompilerVisitor__native_array_instance(self, p0, p1);
3350 var = var1;
3351 RET_LABEL:;
3352 return var;
3353 }
3354 /* method separate_erasure_compiler#SeparateErasureCompilerVisitor#calloc_array for (self: SeparateErasureCompilerVisitor, MType, Array[RuntimeVariable]) */
3355 void separate_erasure_compiler__SeparateErasureCompilerVisitor__calloc_array(val* self, val* p0, val* p1) {
3356 val* var_ret_type /* var ret_type: MType */;
3357 val* var_arguments /* var arguments: Array[RuntimeVariable] */;
3358 short int var /* : Bool */;
3359 int cltype;
3360 int idtype;
3361 const char* var_class_name;
3362 val* var_ret /* var ret: MClassType */;
3363 static val* varonce;
3364 val* var1 /* : String */;
3365 char* var2 /* : NativeString */;
3366 long var3 /* : Int */;
3367 val* var4 /* : FlatString */;
3368 val* var5 /* : MClass */;
3369 val* var7 /* : MClass */;
3370 val* var8 /* : String */;
3371 val* var9 /* : Array[Object] */;
3372 long var10 /* : Int */;
3373 val* var11 /* : NativeArray[Object] */;
3374 val* var12 /* : String */;
3375 static val* varonce13;
3376 val* var14 /* : String */;
3377 char* var15 /* : NativeString */;
3378 long var16 /* : Int */;
3379 val* var17 /* : FlatString */;
3380 val* var18 /* : MClass */;
3381 val* var20 /* : MClass */;
3382 val* var21 /* : String */;
3383 static val* varonce22;
3384 val* var23 /* : String */;
3385 char* var24 /* : NativeString */;
3386 long var25 /* : Int */;
3387 val* var26 /* : FlatString */;
3388 long var27 /* : Int */;
3389 val* var28 /* : nullable Object */;
3390 static val* varonce29;
3391 val* var30 /* : String */;
3392 char* var31 /* : NativeString */;
3393 long var32 /* : Int */;
3394 val* var33 /* : FlatString */;
3395 val* var34 /* : Array[Object] */;
3396 long var35 /* : Int */;
3397 val* var36 /* : NativeArray[Object] */;
3398 val* var37 /* : String */;
3399 val* var38 /* : RuntimeVariable */;
3400 var_ret_type = p0;
3401 var_arguments = p1;
3402 /* <var_ret_type:MType> isa MClassType */
3403 cltype = type_model__MClassType.color;
3404 idtype = type_model__MClassType.id;
3405 if(cltype >= var_ret_type->type->table_size) {
3406 var = 0;
3407 } else {
3408 var = var_ret_type->type->type_table[cltype] == idtype;
3409 }
3410 if (unlikely(!var)) {
3411 var_class_name = var_ret_type == NULL ? "null" : var_ret_type->type->name;
3412 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
3413 PRINT_ERROR(" (%s:%d)\n", "src/separate_erasure_compiler.nit", 598);
3414 show_backtrace(1);
3415 }
3416 var_ret = var_ret_type;
3417 if (varonce) {
3418 var1 = varonce;
3419 } else {
3420 var2 = "NEW_";
3421 var3 = 4;
3422 var4 = string__NativeString__to_s_with_length(var2, var3);
3423 var1 = var4;
3424 varonce = var1;
3425 }
3426 {
3427 { /* Inline model#MClassType#mclass (var_ret) on <var_ret:MClassType> */
3428 var7 = var_ret->attrs[COLOR_model__MClassType___mclass].val; /* _mclass on <var_ret:MClassType> */
3429 if (unlikely(var7 == NULL)) {
3430 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
3431 PRINT_ERROR(" (%s:%d)\n", "src/model/model.nit", 969);
3432 show_backtrace(1);
3433 }
3434 var5 = var7;
3435 RET_LABEL6:(void)0;
3436 }
3437 }
3438 {
3439 var8 = abstract_compiler__MClass__c_name(var5);
3440 }
3441 var9 = NEW_array__Array(&type_array__Arraykernel__Object);
3442 { /* var9 = array_instance Array[Object] */
3443 var10 = 2;
3444 var11 = NEW_array__NativeArray(var10, &type_array__NativeArraykernel__Object);
3445 ((struct instance_array__NativeArray*)var11)->values[0] = (val*) var1;
3446 ((struct instance_array__NativeArray*)var11)->values[1] = (val*) var8;
3447 {
3448 ((void (*)(val*, val*, long))(var9->class->vft[COLOR_array__Array__with_native]))(var9, var11, var10) /* with_native on <var9:Array[Object]>*/;
3449 }
3450 }
3451 {
3452 var12 = ((val* (*)(val*))(var9->class->vft[COLOR_string__Object__to_s]))(var9) /* to_s on <var9:Array[Object]>*/;
3453 }
3454 {
3455 abstract_compiler__AbstractCompilerVisitor__require_declaration(self, var12); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on <self:SeparateErasureCompilerVisitor>*/
3456 }
3457 if (varonce13) {
3458 var14 = varonce13;
3459 } else {
3460 var15 = "NEW_";
3461 var16 = 4;
3462 var17 = string__NativeString__to_s_with_length(var15, var16);
3463 var14 = var17;
3464 varonce13 = var14;
3465 }
3466 {
3467 { /* Inline model#MClassType#mclass (var_ret) on <var_ret:MClassType> */
3468 var20 = var_ret->attrs[COLOR_model__MClassType___mclass].val; /* _mclass on <var_ret:MClassType> */
3469 if (unlikely(var20 == NULL)) {
3470 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
3471 PRINT_ERROR(" (%s:%d)\n", "src/model/model.nit", 969);
3472 show_backtrace(1);
3473 }
3474 var18 = var20;
3475 RET_LABEL19:(void)0;
3476 }
3477 }
3478 {
3479 var21 = abstract_compiler__MClass__c_name(var18);
3480 }
3481 if (varonce22) {
3482 var23 = varonce22;
3483 } else {
3484 var24 = "(";
3485 var25 = 1;
3486 var26 = string__NativeString__to_s_with_length(var24, var25);
3487 var23 = var26;
3488 varonce22 = var23;
3489 }
3490 var27 = 1;
3491 {
3492 var28 = array__Array___91d_93d(var_arguments, var27);
3493 }
3494 if (varonce29) {
3495 var30 = varonce29;
3496 } else {
3497 var31 = ")";
3498 var32 = 1;
3499 var33 = string__NativeString__to_s_with_length(var31, var32);
3500 var30 = var33;
3501 varonce29 = var30;
3502 }
3503 var34 = NEW_array__Array(&type_array__Arraykernel__Object);
3504 { /* var34 = array_instance Array[Object] */
3505 var35 = 5;
3506 var36 = NEW_array__NativeArray(var35, &type_array__NativeArraykernel__Object);
3507 ((struct instance_array__NativeArray*)var36)->values[0] = (val*) var14;
3508 ((struct instance_array__NativeArray*)var36)->values[1] = (val*) var21;
3509 ((struct instance_array__NativeArray*)var36)->values[2] = (val*) var23;
3510 ((struct instance_array__NativeArray*)var36)->values[3] = (val*) var28;
3511 ((struct instance_array__NativeArray*)var36)->values[4] = (val*) var30;
3512 {
3513 ((void (*)(val*, val*, long))(var34->class->vft[COLOR_array__Array__with_native]))(var34, var36, var35) /* with_native on <var34:Array[Object]>*/;
3514 }
3515 }
3516 {
3517 var37 = ((val* (*)(val*))(var34->class->vft[COLOR_string__Object__to_s]))(var34) /* to_s on <var34:Array[Object]>*/;
3518 }
3519 {
3520 var38 = abstract_compiler__AbstractCompilerVisitor__new_expr(self, var37, var_ret_type);
3521 }
3522 {
3523 abstract_compiler__AbstractCompilerVisitor__ret(self, var38); /* Direct call abstract_compiler#AbstractCompilerVisitor#ret on <self:SeparateErasureCompilerVisitor>*/
3524 }
3525 RET_LABEL:;
3526 }
3527 /* method separate_erasure_compiler#SeparateErasureCompilerVisitor#calloc_array for (self: Object, MType, Array[RuntimeVariable]) */
3528 void VIRTUAL_separate_erasure_compiler__SeparateErasureCompilerVisitor__calloc_array(val* self, val* p0, val* p1) {
3529 separate_erasure_compiler__SeparateErasureCompilerVisitor__calloc_array(self, p0, p1); /* Direct call separate_erasure_compiler#SeparateErasureCompilerVisitor#calloc_array on <self:Object(SeparateErasureCompilerVisitor)>*/
3530 RET_LABEL:;
3531 }