X-Git-Url: http://nitlanguage.org diff --git a/c_src/nit__separate_erasure_compiler.sep.2.c b/c_src/nit__separate_erasure_compiler.sep.2.c index b1607cb..1440b54 100644 --- a/c_src/nit__separate_erasure_compiler.sep.2.c +++ b/c_src/nit__separate_erasure_compiler.sep.2.c @@ -5,1414 +5,1298 @@ val* var /* : RuntimeVariable */; val* var_value /* var value: RuntimeVariable */; val* var_mtype /* var mtype: MType */; val* var_tag /* var tag: String */; +val* var1 /* : NativeArray[String] */; static val* varonce; -val* var1 /* : String */; -char* var2 /* : NativeString */; -long var3 /* : Int */; -val* var4 /* : FlatString */; -val* var5 /* : String */; +static val* varonce2; +val* var3 /* : String */; +char* var4 /* : NativeString */; +val* var5 /* : FlatString */; static val* varonce6; val* var7 /* : String */; char* var8 /* : NativeString */; -long var9 /* : Int */; -val* var10 /* : FlatString */; -static val* varonce11; -val* var12 /* : String */; -char* var13 /* : NativeString */; -long var14 /* : Int */; -val* var15 /* : FlatString */; -val* var16 /* : Array[Object] */; -long var17 /* : Int */; -val* var18 /* : NativeArray[Object] */; -val* var19 /* : String */; -val* var20 /* : MClassType */; -val* var21 /* : RuntimeVariable */; +val* var9 /* : FlatString */; +static val* varonce10; +val* var11 /* : String */; +char* var12 /* : NativeString */; +val* var13 /* : FlatString */; +val* var14 /* : String */; +val* var15 /* : String */; +val* var16 /* : String */; +val* var17 /* : MClassType */; +val* var18 /* : RuntimeVariable */; val* var_res /* var res: RuntimeVariable */; -static val* varonce22; +static val* varonce19; +val* var20 /* : String */; +char* var21 /* : NativeString */; +val* var22 /* : FlatString */; val* var23 /* : String */; -char* var24 /* : NativeString */; -long var25 /* : Int */; -val* var26 /* : FlatString */; -val* var27 /* : String */; val* var_cltype /* var cltype: String */; -static val* varonce28; -val* var29 /* : String */; -char* var30 /* : NativeString */; -long var31 /* : Int */; -val* var32 /* : FlatString */; -static val* varonce33; +val* var25 /* : NativeArray[String] */; +static val* varonce24; +static val* varonce26; +val* var27 /* : String */; +char* var28 /* : NativeString */; +val* var29 /* : FlatString */; +static val* varonce30; +val* var31 /* : String */; +char* var32 /* : NativeString */; +val* var33 /* : FlatString */; val* var34 /* : String */; -char* var35 /* : NativeString */; -long var36 /* : Int */; -val* var37 /* : FlatString */; -val* var38 /* : Array[Object] */; -long var39 /* : Int */; -val* var40 /* : NativeArray[Object] */; -val* var41 /* : String */; +static val* varonce35; +val* var36 /* : String */; +char* var37 /* : NativeString */; +val* var38 /* : FlatString */; +val* var39 /* : String */; +val* var_idtype /* var idtype: String */; +val* var41 /* : NativeArray[String] */; +static val* varonce40; static val* varonce42; val* var43 /* : String */; char* var44 /* : NativeString */; -long var45 /* : Int */; -val* var46 /* : FlatString */; +val* var45 /* : FlatString */; +static val* varonce46; val* var47 /* : String */; -val* var_idtype /* var idtype: String */; -static val* varonce48; -val* var49 /* : String */; -char* var50 /* : NativeString */; -long var51 /* : Int */; -val* var52 /* : FlatString */; -static val* varonce53; -val* var54 /* : String */; -char* var55 /* : NativeString */; -long var56 /* : Int */; -val* var57 /* : FlatString */; -val* var58 /* : Array[Object] */; -long var59 /* : Int */; -val* var60 /* : NativeArray[Object] */; -val* var61 /* : String */; -short int var62 /* : Bool */; +char* var48 /* : NativeString */; +val* var49 /* : FlatString */; +val* var50 /* : String */; +short int var51 /* : Bool */; short int var_maybe_null /* var maybe_null: Bool */; -static val* varonce63; -val* var64 /* : String */; -char* var65 /* : NativeString */; -long var66 /* : Int */; -val* var67 /* : FlatString */; +static val* varonce52; +val* var53 /* : String */; +char* var54 /* : NativeString */; +val* var55 /* : FlatString */; val* var_accept_null /* var accept_null: String */; -short int var68 /* : Bool */; +short int var56 /* : Bool */; int cltype; int idtype; -val* var69 /* : MType */; -val* var71 /* : MType */; -static val* varonce72; -val* var73 /* : String */; -char* var74 /* : NativeString */; -long var75 /* : Int */; -val* var76 /* : FlatString */; -short int var77 /* : Bool */; -int cltype78; -int idtype79; -val* var80 /* : nullable StaticFrame */; -val* var82 /* : nullable StaticFrame */; -val* var83 /* : MPropDef */; -val* var85 /* : MPropDef */; -val* var86 /* : MClassDef */; -val* var88 /* : MClassDef */; -val* var89 /* : MClassType */; -val* var91 /* : MClassType */; -val* var92 /* : nullable StaticFrame */; -val* var94 /* : nullable StaticFrame */; -val* var95 /* : MPropDef */; -val* var97 /* : MPropDef */; -val* var98 /* : MClassDef */; -val* var100 /* : MClassDef */; -val* var101 /* : MClassType */; -val* var103 /* : MClassType */; -val* var104 /* : nullable StaticFrame */; -val* var106 /* : nullable StaticFrame */; -val* var107 /* : MPropDef */; -val* var109 /* : MPropDef */; -val* var110 /* : MClassDef */; -val* var112 /* : MClassDef */; -val* var113 /* : MModule */; -val* var115 /* : MModule */; -short int var116 /* : Bool */; -val* var117 /* : MType */; -short int var118 /* : Bool */; -int cltype119; -int idtype120; -val* var121 /* : MType */; -val* var123 /* : MType */; -static val* varonce124; -val* var125 /* : String */; -char* var126 /* : NativeString */; -long var127 /* : Int */; -val* var128 /* : FlatString */; -val* var129 /* : MType */; -val* var131 /* : MType */; -val* var132 /* : nullable StaticFrame */; -val* var134 /* : nullable StaticFrame */; -val* var135 /* : MPropDef */; -val* var137 /* : MPropDef */; -val* var138 /* : MClassDef */; -val* var140 /* : MClassDef */; -val* var141 /* : MModule */; -val* var143 /* : MModule */; -val* var144 /* : nullable StaticFrame */; -val* var146 /* : nullable StaticFrame */; -val* var147 /* : MPropDef */; -val* var149 /* : MPropDef */; -val* var150 /* : MClassDef */; -val* var152 /* : MClassDef */; -val* var153 /* : MClassType */; -val* var155 /* : MClassType */; -short int var156 /* : Bool */; -static val* varonce157; +val* var57 /* : MType */; +val* var59 /* : MType */; +static val* varonce60; +val* var61 /* : String */; +char* var62 /* : NativeString */; +val* var63 /* : FlatString */; +short int var64 /* : Bool */; +int cltype65; +int idtype66; +val* var67 /* : nullable StaticFrame */; +val* var69 /* : nullable StaticFrame */; +val* var70 /* : MPropDef */; +val* var72 /* : MPropDef */; +val* var73 /* : MClassDef */; +val* var75 /* : MClassDef */; +val* var76 /* : MClassType */; +val* var78 /* : MClassType */; +val* var79 /* : nullable StaticFrame */; +val* var81 /* : nullable StaticFrame */; +val* var82 /* : MPropDef */; +val* var84 /* : MPropDef */; +val* var85 /* : MClassDef */; +val* var87 /* : MClassDef */; +val* var88 /* : MClassType */; +val* var90 /* : MClassType */; +val* var91 /* : nullable StaticFrame */; +val* var93 /* : nullable StaticFrame */; +val* var94 /* : MPropDef */; +val* var96 /* : MPropDef */; +val* var97 /* : MClassDef */; +val* var99 /* : MClassDef */; +val* var100 /* : MModule */; +val* var102 /* : MModule */; +val* var103 /* : MType */; +short int var104 /* : Bool */; +int cltype105; +int idtype106; +val* var107 /* : MType */; +val* var109 /* : MType */; +static val* varonce110; +val* var111 /* : String */; +char* var112 /* : NativeString */; +val* var113 /* : FlatString */; +val* var114 /* : MType */; +val* var116 /* : MType */; +val* var117 /* : nullable StaticFrame */; +val* var119 /* : nullable StaticFrame */; +val* var120 /* : MPropDef */; +val* var122 /* : MPropDef */; +val* var123 /* : MClassDef */; +val* var125 /* : MClassDef */; +val* var126 /* : MModule */; +val* var128 /* : MModule */; +val* var129 /* : nullable StaticFrame */; +val* var131 /* : nullable StaticFrame */; +val* var132 /* : MPropDef */; +val* var134 /* : MPropDef */; +val* var135 /* : MClassDef */; +val* var137 /* : MClassDef */; +val* var138 /* : MClassType */; +val* var140 /* : MClassType */; +short int var141 /* : Bool */; +val* var143 /* : NativeArray[String] */; +static val* varonce142; +static val* varonce144; +val* var145 /* : String */; +char* var146 /* : NativeString */; +val* var147 /* : FlatString */; +static val* varonce148; +val* var149 /* : String */; +char* var150 /* : NativeString */; +val* var151 /* : FlatString */; +static val* varonce152; +val* var153 /* : String */; +char* var154 /* : NativeString */; +val* var155 /* : FlatString */; +val* var156 /* : String */; +val* var157 /* : String */; val* var158 /* : String */; -char* var159 /* : NativeString */; -long var160 /* : Int */; -val* var161 /* : FlatString */; -val* var162 /* : String */; -static val* varonce163; -val* var164 /* : String */; -char* var165 /* : NativeString */; -long var166 /* : Int */; -val* var167 /* : FlatString */; -static val* varonce168; -val* var169 /* : String */; -char* var170 /* : NativeString */; -long var171 /* : Int */; -val* var172 /* : FlatString */; -val* var173 /* : Array[Object] */; -long var174 /* : Int */; -val* var175 /* : NativeArray[Object] */; -val* var176 /* : String */; -val* var177 /* : AbstractCompiler */; -val* var179 /* : AbstractCompiler */; -val* var180 /* : ModelBuilder */; -val* var182 /* : ModelBuilder */; -val* var183 /* : ToolContext */; -val* var185 /* : ToolContext */; -val* var186 /* : OptionBool */; -val* var188 /* : OptionBool */; -val* var189 /* : nullable Object */; -val* var191 /* : nullable Object */; -short int var192 /* : Bool */; -val* var193 /* : AbstractCompiler */; -val* var195 /* : AbstractCompiler */; -val* var196 /* : HashMap[String, Int] */; -val* var198 /* : HashMap[String, Int] */; +val* var159 /* : String */; +val* var160 /* : AbstractCompiler */; +val* var162 /* : AbstractCompiler */; +val* var163 /* : ModelBuilder */; +val* var165 /* : ModelBuilder */; +val* var166 /* : ToolContext */; +val* var168 /* : ToolContext */; +val* var169 /* : OptionBool */; +val* var171 /* : OptionBool */; +val* var172 /* : nullable Object */; +val* var174 /* : nullable Object */; +short int var175 /* : Bool */; +val* var176 /* : AbstractCompiler */; +val* var178 /* : AbstractCompiler */; +val* var179 /* : HashMap[String, Int] */; +val* var181 /* : HashMap[String, Int] */; val* var_ /* var : HashMap[String, Int] */; -val* var_199 /* var : String */; -val* var200 /* : nullable Object */; -long var201 /* : Int */; -long var202 /* : Int */; -short int var204 /* : Bool */; -int cltype205; -int idtype206; +val* var_182 /* var : String */; +val* var183 /* : nullable Object */; +long var184 /* : Int */; +short int var186 /* : Bool */; +int cltype187; +int idtype188; const char* var_class_name; -long var207 /* : Int */; -long var208 /* : Int */; -val* var209 /* : nullable Object */; +long var189 /* : Int */; +long var190 /* : Int */; +val* var191 /* : nullable Object */; +val* var193 /* : NativeArray[String] */; +static val* varonce192; +static val* varonce194; +val* var195 /* : String */; +char* var196 /* : NativeString */; +val* var197 /* : FlatString */; +static val* varonce198; +val* var199 /* : String */; +char* var200 /* : NativeString */; +val* var201 /* : FlatString */; +val* var202 /* : String */; +val* var203 /* : MType */; +val* var205 /* : MType */; +short int var206 /* : Bool */; +short int var207 /* : Bool */; +val* var209 /* : NativeArray[String] */; +static val* varonce208; static val* varonce210; val* var211 /* : String */; char* var212 /* : NativeString */; -long var213 /* : Int */; -val* var214 /* : FlatString */; -static val* varonce215; -val* var216 /* : String */; -char* var217 /* : NativeString */; -long var218 /* : Int */; -val* var219 /* : FlatString */; -val* var220 /* : Array[Object] */; -long var221 /* : Int */; -val* var222 /* : NativeArray[Object] */; -val* var223 /* : String */; -val* var224 /* : MType */; -val* var226 /* : MType */; -val* var227 /* : String */; +val* var213 /* : FlatString */; +val* var214 /* : String */; +val* var215 /* : String */; +val* var_class_ptr /* var class_ptr: nullable Object */; +val* var216 /* : MType */; +val* var218 /* : MType */; +short int var219 /* : Bool */; +int cltype220; +int idtype221; +const char* var_class_name222; +val* var223 /* : MClass */; +val* var225 /* : MClass */; +val* var_mclass /* var mclass: MClass */; +val* var227 /* : NativeArray[String] */; +static val* varonce226; static val* varonce228; val* var229 /* : String */; char* var230 /* : NativeString */; -long var231 /* : Int */; -val* var232 /* : FlatString */; -short int var233 /* : Bool */; +val* var231 /* : FlatString */; +val* var232 /* : String */; +val* var233 /* : String */; +val* var235 /* : NativeArray[String] */; static val* varonce234; -val* var235 /* : String */; -char* var236 /* : NativeString */; -long var237 /* : Int */; -val* var238 /* : FlatString */; -val* var239 /* : Array[Object] */; -long var240 /* : Int */; -val* var241 /* : NativeArray[Object] */; -val* var242 /* : String */; -val* var_class_ptr /* var class_ptr: nullable Object */; -val* var243 /* : MType */; -val* var245 /* : MType */; +static val* varonce236; +val* var237 /* : String */; +char* var238 /* : NativeString */; +val* var239 /* : FlatString */; +static val* varonce240; +val* var241 /* : String */; +char* var242 /* : NativeString */; +val* var243 /* : FlatString */; +val* var244 /* : String */; +val* var245 /* : String */; short int var246 /* : Bool */; int cltype247; int idtype248; -const char* var_class_name249; -val* var250 /* : MClass */; -val* var252 /* : MClass */; -val* var_mclass /* var mclass: MClass */; -static val* varonce253; -val* var254 /* : String */; -char* var255 /* : NativeString */; -long var256 /* : Int */; -val* var257 /* : FlatString */; +val* var250 /* : NativeArray[String] */; +static val* varonce249; +static val* varonce251; +val* var252 /* : String */; +char* var253 /* : NativeString */; +val* var254 /* : FlatString */; +val* var255 /* : MClass */; +val* var257 /* : MClass */; val* var258 /* : String */; -val* var259 /* : Array[Object] */; -long var260 /* : Int */; -val* var261 /* : NativeArray[Object] */; -val* var262 /* : String */; -static val* varonce263; -val* var264 /* : String */; -char* var265 /* : NativeString */; -long var266 /* : Int */; -val* var267 /* : FlatString */; -val* var268 /* : String */; -static val* varonce269; -val* var270 /* : String */; -char* var271 /* : NativeString */; -long var272 /* : Int */; -val* var273 /* : FlatString */; -val* var274 /* : Array[Object] */; -long var275 /* : Int */; -val* var276 /* : NativeArray[Object] */; -val* var277 /* : String */; -short int var278 /* : Bool */; -int cltype279; -int idtype280; +val* var259 /* : String */; +val* var261 /* : NativeArray[String] */; +static val* varonce260; +static val* varonce262; +val* var263 /* : String */; +char* var264 /* : NativeString */; +val* var265 /* : FlatString */; +static val* varonce266; +val* var267 /* : String */; +char* var268 /* : NativeString */; +val* var269 /* : FlatString */; +val* var270 /* : MClass */; +val* var272 /* : MClass */; +val* var273 /* : String */; +val* var274 /* : String */; +val* var276 /* : NativeArray[String] */; +static val* varonce275; +static val* varonce277; +val* var278 /* : String */; +char* var279 /* : NativeString */; +val* var280 /* : FlatString */; static val* varonce281; val* var282 /* : String */; char* var283 /* : NativeString */; -long var284 /* : Int */; -val* var285 /* : FlatString */; -val* var286 /* : MClass */; -val* var288 /* : MClass */; +val* var284 /* : FlatString */; +val* var285 /* : MClass */; +val* var287 /* : MClass */; +val* var288 /* : String */; val* var289 /* : String */; -val* var290 /* : Array[Object] */; -long var291 /* : Int */; -val* var292 /* : NativeArray[Object] */; -val* var293 /* : String */; -static val* varonce294; -val* var295 /* : String */; -char* var296 /* : NativeString */; -long var297 /* : Int */; -val* var298 /* : FlatString */; -val* var299 /* : MClass */; -val* var301 /* : MClass */; -val* var302 /* : String */; -static val* varonce303; -val* var304 /* : String */; -char* var305 /* : NativeString */; -long var306 /* : Int */; -val* var307 /* : FlatString */; -val* var308 /* : Array[Object] */; -long var309 /* : Int */; -val* var310 /* : NativeArray[Object] */; -val* var311 /* : String */; -static val* varonce312; -val* var313 /* : String */; -char* var314 /* : NativeString */; +val* var290 /* : AbstractCompiler */; +val* var292 /* : AbstractCompiler */; +val* var293 /* : ModelBuilder */; +val* var295 /* : ModelBuilder */; +val* var296 /* : ToolContext */; +val* var298 /* : ToolContext */; +val* var299 /* : OptionBool */; +val* var301 /* : OptionBool */; +val* var302 /* : nullable Object */; +val* var304 /* : nullable Object */; +short int var305 /* : Bool */; +val* var306 /* : AbstractCompiler */; +val* var308 /* : AbstractCompiler */; +val* var309 /* : HashMap[String, Int] */; +val* var311 /* : HashMap[String, Int] */; +val* var_312 /* var : HashMap[String, Int] */; +val* var_313 /* var : String */; +val* var314 /* : nullable Object */; long var315 /* : Int */; -val* var316 /* : FlatString */; -val* var317 /* : MClass */; -val* var319 /* : MClass */; -val* var320 /* : String */; -static val* varonce321; -val* var322 /* : String */; -char* var323 /* : NativeString */; -long var324 /* : Int */; -val* var325 /* : FlatString */; -val* var326 /* : Array[Object] */; -long var327 /* : Int */; -val* var328 /* : NativeArray[Object] */; -val* var329 /* : String */; -val* var330 /* : AbstractCompiler */; -val* var332 /* : AbstractCompiler */; -val* var333 /* : ModelBuilder */; -val* var335 /* : ModelBuilder */; -val* var336 /* : ToolContext */; -val* var338 /* : ToolContext */; -val* var339 /* : OptionBool */; -val* var341 /* : OptionBool */; -val* var342 /* : nullable Object */; +short int var317 /* : Bool */; +int cltype318; +int idtype319; +const char* var_class_name320; +long var321 /* : Int */; +long var322 /* : Int */; +val* var323 /* : nullable Object */; +val* var325 /* : NativeArray[String] */; +static val* varonce324; +static val* varonce326; +val* var327 /* : String */; +char* var328 /* : NativeString */; +val* var329 /* : FlatString */; +static val* varonce330; +val* var331 /* : String */; +char* var332 /* : NativeString */; +val* var333 /* : FlatString */; +val* var334 /* : String */; +short int var335 /* : Bool */; +int cltype336; +int idtype337; +val* var338 /* : nullable StaticFrame */; +val* var340 /* : nullable StaticFrame */; +val* var341 /* : Array[RuntimeVariable] */; +val* var343 /* : Array[RuntimeVariable] */; val* var344 /* : nullable Object */; -short int var345 /* : Bool */; -val* var346 /* : AbstractCompiler */; -val* var348 /* : AbstractCompiler */; -val* var349 /* : HashMap[String, Int] */; -val* var351 /* : HashMap[String, Int] */; -val* var_352 /* var : HashMap[String, Int] */; -val* var_353 /* var : String */; -val* var354 /* : nullable Object */; -long var355 /* : Int */; -long var356 /* : Int */; -short int var358 /* : Bool */; -int cltype359; -int idtype360; -const char* var_class_name361; -long var362 /* : Int */; -long var363 /* : Int */; -val* var364 /* : nullable Object */; -static val* varonce365; -val* var366 /* : String */; -char* var367 /* : NativeString */; -long var368 /* : Int */; -val* var369 /* : FlatString */; -static val* varonce370; -val* var371 /* : String */; -char* var372 /* : NativeString */; -long var373 /* : Int */; -val* var374 /* : FlatString */; -val* var375 /* : Array[Object] */; -long var376 /* : Int */; -val* var377 /* : NativeArray[Object] */; -val* var378 /* : String */; -short int var379 /* : Bool */; -int cltype380; -int idtype381; -val* var382 /* : nullable StaticFrame */; -val* var384 /* : nullable StaticFrame */; -val* var385 /* : Array[RuntimeVariable] */; -val* var387 /* : Array[RuntimeVariable] */; -val* var388 /* : nullable Object */; val* var_recv /* var recv: RuntimeVariable */; -val* var389 /* : MType */; -val* var391 /* : MType */; -val* var392 /* : String */; -static val* varonce393; -val* var394 /* : String */; -char* var395 /* : NativeString */; -long var396 /* : Int */; -val* var397 /* : FlatString */; -short int var398 /* : Bool */; -static val* varonce399; -val* var400 /* : String */; -char* var401 /* : NativeString */; -long var402 /* : Int */; -val* var403 /* : FlatString */; -val* var404 /* : Array[Object] */; -long var405 /* : Int */; -val* var406 /* : NativeArray[Object] */; -val* var407 /* : String */; +val* var345 /* : MType */; +val* var347 /* : MType */; +short int var348 /* : Bool */; +short int var349 /* : Bool */; +val* var351 /* : NativeArray[String] */; +static val* varonce350; +static val* varonce352; +val* var353 /* : String */; +char* var354 /* : NativeString */; +val* var355 /* : FlatString */; +val* var356 /* : String */; +val* var357 /* : String */; val* var_recv_ptr /* var recv_ptr: nullable Object */; -val* var408 /* : MType */; -val* var410 /* : MType */; -short int var411 /* : Bool */; -int cltype412; -int idtype413; -const char* var_class_name414; -val* var415 /* : MClass */; -val* var417 /* : MClass */; -val* var_mclass418 /* var mclass: MClass */; +val* var358 /* : MType */; +val* var360 /* : MType */; +short int var361 /* : Bool */; +int cltype362; +int idtype363; +const char* var_class_name364; +val* var365 /* : MClass */; +val* var367 /* : MClass */; +val* var_mclass368 /* var mclass: MClass */; +val* var370 /* : NativeArray[String] */; +static val* varonce369; +static val* varonce371; +val* var372 /* : String */; +char* var373 /* : NativeString */; +val* var374 /* : FlatString */; +val* var375 /* : String */; +val* var376 /* : String */; +val* var378 /* : NativeArray[String] */; +static val* varonce377; +static val* varonce379; +val* var380 /* : String */; +char* var381 /* : NativeString */; +val* var382 /* : FlatString */; +static val* varonce383; +val* var384 /* : String */; +char* var385 /* : NativeString */; +val* var386 /* : FlatString */; +val* var387 /* : String */; +val* var388 /* : String */; +static val* varonce389; +val* var390 /* : String */; +char* var391 /* : NativeString */; +val* var392 /* : FlatString */; +val* var393 /* : String */; +val* var_entry /* var entry: String */; +val* var395 /* : NativeArray[String] */; +static val* varonce394; +static val* varonce396; +val* var397 /* : String */; +char* var398 /* : NativeString */; +val* var399 /* : FlatString */; +static val* varonce400; +val* var401 /* : String */; +char* var402 /* : NativeString */; +val* var403 /* : FlatString */; +val* var404 /* : String */; +val* var405 /* : MVirtualTypeProp */; +val* var407 /* : MVirtualTypeProp */; +val* var408 /* : String */; +val* var410 /* : NativeArray[String] */; +static val* varonce409; +static val* varonce411; +val* var412 /* : String */; +char* var413 /* : NativeString */; +val* var414 /* : FlatString */; +static val* varonce415; +val* var416 /* : String */; +char* var417 /* : NativeString */; +val* var418 /* : FlatString */; static val* varonce419; val* var420 /* : String */; char* var421 /* : NativeString */; -long var422 /* : Int */; -val* var423 /* : FlatString */; -val* var424 /* : String */; -val* var425 /* : Array[Object] */; -long var426 /* : Int */; -val* var427 /* : NativeArray[Object] */; -val* var428 /* : String */; -static val* varonce429; -val* var430 /* : String */; -char* var431 /* : NativeString */; -long var432 /* : Int */; +val* var422 /* : FlatString */; +val* var423 /* : MVirtualTypeProp */; +val* var425 /* : MVirtualTypeProp */; +val* var426 /* : String */; +val* var427 /* : String */; +val* var429 /* : NativeArray[String] */; +static val* varonce428; +static val* varonce430; +val* var431 /* : String */; +char* var432 /* : NativeString */; val* var433 /* : FlatString */; -val* var434 /* : String */; -static val* varonce435; -val* var436 /* : String */; -char* var437 /* : NativeString */; -long var438 /* : Int */; -val* var439 /* : FlatString */; -val* var440 /* : Array[Object] */; -long var441 /* : Int */; -val* var442 /* : NativeArray[Object] */; -val* var443 /* : String */; -static val* varonce444; -val* var445 /* : String */; -char* var446 /* : NativeString */; -long var447 /* : Int */; +static val* varonce434; +val* var435 /* : String */; +char* var436 /* : NativeString */; +val* var437 /* : FlatString */; +val* var438 /* : String */; +val* var440 /* : NativeArray[String] */; +static val* varonce439; +static val* varonce441; +val* var442 /* : String */; +char* var443 /* : NativeString */; +val* var444 /* : FlatString */; +static val* varonce445; +val* var446 /* : String */; +char* var447 /* : NativeString */; val* var448 /* : FlatString */; val* var449 /* : String */; -val* var_entry /* var entry: String */; -static val* varonce450; -val* var451 /* : String */; -char* var452 /* : NativeString */; -long var453 /* : Int */; -val* var454 /* : FlatString */; -static val* varonce455; -val* var456 /* : String */; -char* var457 /* : NativeString */; -long var458 /* : Int */; -val* var459 /* : FlatString */; -val* var460 /* : Array[Object] */; -long var461 /* : Int */; -val* var462 /* : NativeArray[Object] */; -val* var463 /* : String */; -val* var464 /* : MVirtualTypeProp */; -val* var466 /* : MVirtualTypeProp */; -val* var467 /* : String */; +short int var450 /* : Bool */; +short int var_451 /* var : Bool */; +static val* varonce452; +val* var453 /* : String */; +char* var454 /* : NativeString */; +val* var455 /* : FlatString */; +short int var456 /* : Bool */; +static val* varonce457; +val* var458 /* : String */; +char* var459 /* : NativeString */; +val* var460 /* : FlatString */; +val* var461 /* : String */; +val* var_is_nullable /* var is_nullable: String */; +val* var463 /* : NativeArray[String] */; +static val* varonce462; +static val* varonce464; +val* var465 /* : String */; +char* var466 /* : NativeString */; +val* var467 /* : FlatString */; static val* varonce468; val* var469 /* : String */; char* var470 /* : NativeString */; -long var471 /* : Int */; -val* var472 /* : FlatString */; +val* var471 /* : FlatString */; +val* var472 /* : String */; +val* var474 /* : NativeArray[String] */; static val* varonce473; -val* var474 /* : String */; -char* var475 /* : NativeString */; -long var476 /* : Int */; -val* var477 /* : FlatString */; -val* var478 /* : MVirtualTypeProp */; -val* var480 /* : MVirtualTypeProp */; -val* var481 /* : String */; -static val* varonce482; +static val* varonce475; +val* var476 /* : String */; +char* var477 /* : NativeString */; +val* var478 /* : FlatString */; +static val* varonce479; +val* var480 /* : String */; +char* var481 /* : NativeString */; +val* var482 /* : FlatString */; val* var483 /* : String */; -char* var484 /* : NativeString */; -long var485 /* : Int */; -val* var486 /* : FlatString */; -val* var487 /* : Array[Object] */; -long var488 /* : Int */; -val* var489 /* : NativeArray[Object] */; -val* var490 /* : String */; -static val* varonce491; -val* var492 /* : String */; -char* var493 /* : NativeString */; -long var494 /* : Int */; -val* var495 /* : FlatString */; -static val* varonce496; -val* var497 /* : String */; -char* var498 /* : NativeString */; -long var499 /* : Int */; -val* var500 /* : FlatString */; -val* var501 /* : Array[Object] */; -long var502 /* : Int */; -val* var503 /* : NativeArray[Object] */; -val* var504 /* : String */; -static val* varonce505; -val* var506 /* : String */; -char* var507 /* : NativeString */; -long var508 /* : Int */; -val* var509 /* : FlatString */; -static val* varonce510; -val* var511 /* : String */; -char* var512 /* : NativeString */; -long var513 /* : Int */; -val* var514 /* : FlatString */; -val* var515 /* : Array[Object] */; +val* var484 /* : String */; +val* var485 /* : AbstractCompiler */; +val* var487 /* : AbstractCompiler */; +val* var488 /* : ModelBuilder */; +val* var490 /* : ModelBuilder */; +val* var491 /* : ToolContext */; +val* var493 /* : ToolContext */; +val* var494 /* : OptionBool */; +val* var496 /* : OptionBool */; +val* var497 /* : nullable Object */; +val* var499 /* : nullable Object */; +short int var500 /* : Bool */; +val* var501 /* : AbstractCompiler */; +val* var503 /* : AbstractCompiler */; +val* var504 /* : HashMap[String, Int] */; +val* var506 /* : HashMap[String, Int] */; +val* var_507 /* var : HashMap[String, Int] */; +val* var_508 /* var : String */; +val* var509 /* : nullable Object */; +long var510 /* : Int */; +short int var512 /* : Bool */; +int cltype513; +int idtype514; +const char* var_class_name515; long var516 /* : Int */; -val* var517 /* : NativeArray[Object] */; -val* var518 /* : String */; -short int var519 /* : Bool */; -short int var_520 /* var : Bool */; +long var517 /* : Int */; +val* var518 /* : nullable Object */; +val* var520 /* : NativeArray[String] */; +static val* varonce519; static val* varonce521; val* var522 /* : String */; char* var523 /* : NativeString */; -long var524 /* : Int */; -val* var525 /* : FlatString */; -short int var526 /* : Bool */; -static val* varonce527; -val* var528 /* : String */; -char* var529 /* : NativeString */; -long var530 /* : Int */; -val* var531 /* : FlatString */; -val* var532 /* : String */; -val* var_is_nullable /* var is_nullable: String */; -static val* varonce533; -val* var534 /* : String */; -char* var535 /* : NativeString */; -long var536 /* : Int */; -val* var537 /* : FlatString */; -static val* varonce538; -val* var539 /* : String */; -char* var540 /* : NativeString */; -long var541 /* : Int */; -val* var542 /* : FlatString */; -val* var543 /* : Array[Object] */; -long var544 /* : Int */; -val* var545 /* : NativeArray[Object] */; +val* var524 /* : FlatString */; +static val* varonce525; +val* var526 /* : String */; +char* var527 /* : NativeString */; +val* var528 /* : FlatString */; +val* var529 /* : String */; +val* var531 /* : NativeArray[String] */; +static val* varonce530; +static val* varonce532; +val* var533 /* : String */; +char* var534 /* : NativeString */; +val* var535 /* : FlatString */; +static val* varonce536; +val* var537 /* : String */; +char* var538 /* : NativeString */; +val* var539 /* : FlatString */; +static val* varonce540; +val* var541 /* : String */; +char* var542 /* : NativeString */; +val* var543 /* : FlatString */; +val* var544 /* : String */; +val* var545 /* : String */; val* var546 /* : String */; +val* var548 /* : NativeArray[String] */; static val* varonce547; -val* var548 /* : String */; -char* var549 /* : NativeString */; -long var550 /* : Int */; -val* var551 /* : FlatString */; -static val* varonce552; -val* var553 /* : String */; -char* var554 /* : NativeString */; -long var555 /* : Int */; +static val* varonce549; +val* var550 /* : String */; +char* var551 /* : NativeString */; +val* var552 /* : FlatString */; +static val* varonce553; +val* var554 /* : String */; +char* var555 /* : NativeString */; val* var556 /* : FlatString */; -val* var557 /* : Array[Object] */; -long var558 /* : Int */; -val* var559 /* : NativeArray[Object] */; -val* var560 /* : String */; -val* var561 /* : String */; -val* var562 /* : AbstractCompiler */; -val* var564 /* : AbstractCompiler */; -val* var565 /* : ModelBuilder */; -val* var567 /* : ModelBuilder */; -val* var568 /* : ToolContext */; -val* var570 /* : ToolContext */; -val* var571 /* : OptionBool */; -val* var573 /* : OptionBool */; -val* var574 /* : nullable Object */; -val* var576 /* : nullable Object */; -short int var577 /* : Bool */; -val* var578 /* : AbstractCompiler */; -val* var580 /* : AbstractCompiler */; -val* var581 /* : HashMap[String, Int] */; -val* var583 /* : HashMap[String, Int] */; -val* var_584 /* var : HashMap[String, Int] */; -val* var_585 /* var : String */; -val* var586 /* : nullable Object */; -long var587 /* : Int */; -long var588 /* : Int */; -short int var590 /* : Bool */; -int cltype591; -int idtype592; -const char* var_class_name593; -long var594 /* : Int */; -long var595 /* : Int */; -val* var596 /* : nullable Object */; -static val* varonce597; -val* var598 /* : String */; -char* var599 /* : NativeString */; -long var600 /* : Int */; +val* var557 /* : String */; +val* var558 /* : String */; +val* var560 /* : NativeArray[String] */; +static val* varonce559; +static val* varonce561; +val* var562 /* : String */; +char* var563 /* : NativeString */; +val* var564 /* : FlatString */; +static val* varonce565; +val* var566 /* : String */; +char* var567 /* : NativeString */; +val* var568 /* : FlatString */; +val* var569 /* : String */; +val* var570 /* : String */; +static val* varonce571; +val* var572 /* : String */; +char* var573 /* : NativeString */; +val* var574 /* : FlatString */; +val* var576 /* : NativeArray[String] */; +static val* varonce575; +static val* varonce577; +val* var578 /* : String */; +char* var579 /* : NativeString */; +val* var580 /* : FlatString */; +static val* varonce581; +val* var582 /* : String */; +char* var583 /* : NativeString */; +val* var584 /* : FlatString */; +static val* varonce585; +val* var586 /* : String */; +char* var587 /* : NativeString */; +val* var588 /* : FlatString */; +val* var589 /* : String */; +val* var591 /* : NativeArray[String] */; +static val* varonce590; +static val* varonce592; +val* var593 /* : String */; +char* var594 /* : NativeString */; +val* var595 /* : FlatString */; +val* var596 /* : String */; +val* var597 /* : String */; +static val* varonce598; +val* var599 /* : String */; +char* var600 /* : NativeString */; val* var601 /* : FlatString */; +val* var603 /* : NativeArray[String] */; static val* varonce602; -val* var603 /* : String */; -char* var604 /* : NativeString */; -long var605 /* : Int */; -val* var606 /* : FlatString */; -val* var607 /* : Array[Object] */; -long var608 /* : Int */; -val* var609 /* : NativeArray[Object] */; -val* var610 /* : String */; -static val* varonce611; -val* var612 /* : String */; -char* var613 /* : NativeString */; -long var614 /* : Int */; +static val* varonce604; +val* var605 /* : String */; +char* var606 /* : NativeString */; +val* var607 /* : FlatString */; +static val* varonce608; +val* var609 /* : String */; +char* var610 /* : NativeString */; +val* var611 /* : FlatString */; +static val* varonce612; +val* var613 /* : String */; +char* var614 /* : NativeString */; val* var615 /* : FlatString */; -val* var616 /* : String */; -static val* varonce617; -val* var618 /* : String */; -char* var619 /* : NativeString */; -long var620 /* : Int */; -val* var621 /* : FlatString */; +static val* varonce616; +val* var617 /* : String */; +char* var618 /* : NativeString */; +val* var619 /* : FlatString */; +val* var620 /* : String */; +val* var621 /* : String */; static val* varonce622; val* var623 /* : String */; char* var624 /* : NativeString */; -long var625 /* : Int */; -val* var626 /* : FlatString */; -val* var627 /* : Array[Object] */; -long var628 /* : Int */; -val* var629 /* : NativeArray[Object] */; -val* var630 /* : String */; -static val* varonce631; -val* var632 /* : String */; -char* var633 /* : NativeString */; -long var634 /* : Int */; -val* var635 /* : FlatString */; -static val* varonce636; -val* var637 /* : String */; -char* var638 /* : NativeString */; -long var639 /* : Int */; -val* var640 /* : FlatString */; -val* var641 /* : Array[Object] */; -long var642 /* : Int */; -val* var643 /* : NativeArray[Object] */; -val* var644 /* : String */; -static val* varonce645; -val* var646 /* : String */; -char* var647 /* : NativeString */; -long var648 /* : Int */; -val* var649 /* : FlatString */; -static val* varonce650; -val* var651 /* : String */; -char* var652 /* : NativeString */; -long var653 /* : Int */; -val* var654 /* : FlatString */; -val* var655 /* : Array[Object] */; -long var656 /* : Int */; -val* var657 /* : NativeArray[Object] */; -val* var658 /* : String */; -static val* varonce659; -val* var660 /* : String */; -char* var661 /* : NativeString */; -long var662 /* : Int */; -val* var663 /* : FlatString */; -static val* varonce664; -val* var665 /* : String */; -char* var666 /* : NativeString */; -long var667 /* : Int */; -val* var668 /* : FlatString */; -static val* varonce669; -val* var670 /* : String */; -char* var671 /* : NativeString */; -long var672 /* : Int */; -val* var673 /* : FlatString */; -static val* varonce674; -val* var675 /* : String */; -char* var676 /* : NativeString */; -long var677 /* : Int */; -val* var678 /* : FlatString */; -val* var679 /* : Array[Object] */; -long var680 /* : Int */; -val* var681 /* : NativeArray[Object] */; -val* var682 /* : String */; -static val* varonce683; -val* var684 /* : String */; -char* var685 /* : NativeString */; -long var686 /* : Int */; -val* var687 /* : FlatString */; -val* var688 /* : Array[Object] */; -long var689 /* : Int */; -val* var690 /* : NativeArray[Object] */; -val* var691 /* : String */; -static val* varonce692; -val* var693 /* : String */; -char* var694 /* : NativeString */; -long var695 /* : Int */; -val* var696 /* : FlatString */; -static val* varonce697; -val* var698 /* : String */; -char* var699 /* : NativeString */; -long var700 /* : Int */; -val* var701 /* : FlatString */; -static val* varonce702; -val* var703 /* : String */; -char* var704 /* : NativeString */; -long var705 /* : Int */; -val* var706 /* : FlatString */; -static val* varonce707; -val* var708 /* : String */; -char* var709 /* : NativeString */; -long var710 /* : Int */; -val* var711 /* : FlatString */; -static val* varonce712; -val* var713 /* : String */; -char* var714 /* : NativeString */; -long var715 /* : Int */; -val* var716 /* : FlatString */; -val* var717 /* : Array[Object] */; -long var718 /* : Int */; -val* var719 /* : NativeArray[Object] */; -val* var720 /* : String */; -static val* varonce721; -val* var722 /* : String */; -char* var723 /* : NativeString */; -long var724 /* : Int */; -val* var725 /* : FlatString */; -static val* varonce726; -val* var727 /* : String */; -char* var728 /* : NativeString */; -long var729 /* : Int */; -val* var730 /* : FlatString */; +val* var625 /* : FlatString */; +static val* varonce626; +val* var627 /* : String */; +char* var628 /* : NativeString */; +val* var629 /* : FlatString */; var_value = p0; var_mtype = p1; var_tag = p2; -if (varonce) { -var1 = varonce; -} else { -var2 = "/* type test for "; -var3 = 17; -var4 = standard___standard__NativeString___to_s_with_length(var2, var3); -var1 = var4; -varonce = var1; -} -{ -var5 = nit___nit__RuntimeVariable___standard__string__Object__inspect(var_value); -} -if (varonce6) { +if (unlikely(varonce==NULL)) { +var1 = NEW_standard__NativeArray(5l, &type_standard__NativeArray__standard__String); +if (likely(varonce2!=NULL)) { +var3 = varonce2; +} else { +var4 = "/* type test for "; +var5 = standard___standard__NativeString___to_s_with_length(var4, 17l); +var3 = var5; +varonce2 = var3; +} +((struct instance_standard__NativeArray*)var1)->values[0]=var3; +if (likely(varonce6!=NULL)) { var7 = varonce6; } else { var8 = " isa "; -var9 = 5; -var10 = standard___standard__NativeString___to_s_with_length(var8, var9); -var7 = var10; +var9 = standard___standard__NativeString___to_s_with_length(var8, 5l); +var7 = var9; varonce6 = var7; } -if (varonce11) { -var12 = varonce11; +((struct instance_standard__NativeArray*)var1)->values[2]=var7; +if (likely(varonce10!=NULL)) { +var11 = varonce10; } else { -var13 = " */"; -var14 = 3; -var15 = standard___standard__NativeString___to_s_with_length(var13, var14); -var12 = var15; -varonce11 = var12; +var12 = " */"; +var13 = standard___standard__NativeString___to_s_with_length(var12, 3l); +var11 = var13; +varonce10 = var11; +} +((struct instance_standard__NativeArray*)var1)->values[4]=var11; +} else { +var1 = varonce; +varonce = NULL; } -var16 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var16 = array_instance Array[Object] */ -var17 = 5; -var18 = NEW_standard__NativeArray(var17, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var18)->values[0] = (val*) var1; -((struct instance_standard__NativeArray*)var18)->values[1] = (val*) var5; -((struct instance_standard__NativeArray*)var18)->values[2] = (val*) var7; -((struct instance_standard__NativeArray*)var18)->values[3] = (val*) var_mtype; -((struct instance_standard__NativeArray*)var18)->values[4] = (val*) var12; { -((void (*)(val* self, val* p0, long p1))(var16->class->vft[COLOR_standard__array__Array__with_native]))(var16, var18, var17) /* with_native on */; +var14 = nit___nit__RuntimeVariable___standard__string__Object__inspect(var_value); } +((struct instance_standard__NativeArray*)var1)->values[1]=var14; +{ +var15 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_standard__string__Object__to_s]))(var_mtype); /* to_s on */ } +((struct instance_standard__NativeArray*)var1)->values[3]=var15; { -var19 = ((val* (*)(val* self))(var16->class->vft[COLOR_standard__string__Object__to_s]))(var16) /* to_s on */; +var16 = ((val*(*)(val* self))(var1->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var1); /* native_to_s on */ } +varonce = var1; { -nit___nit__AbstractCompilerVisitor___add(self, var19); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var16); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } { -var20 = nit___nit__AbstractCompilerVisitor___bool_type(self); +var17 = nit___nit__AbstractCompilerVisitor___bool_type(self); } { -var21 = nit___nit__AbstractCompilerVisitor___new_var(self, var20); +var18 = nit___nit__AbstractCompilerVisitor___new_var(self, var17); } -var_res = var21; -if (varonce22) { -var23 = varonce22; +var_res = var18; +if (likely(varonce19!=NULL)) { +var20 = varonce19; } else { -var24 = "cltype"; -var25 = 6; -var26 = standard___standard__NativeString___to_s_with_length(var24, var25); -var23 = var26; -varonce22 = var23; +var21 = "cltype"; +var22 = standard___standard__NativeString___to_s_with_length(var21, 6l); +var20 = var22; +varonce19 = var20; } { -var27 = nit___nit__AbstractCompilerVisitor___get_name(self, var23); +var23 = nit___nit__AbstractCompilerVisitor___get_name(self, var20); } -var_cltype = var27; -if (varonce28) { -var29 = varonce28; +var_cltype = var23; +if (unlikely(varonce24==NULL)) { +var25 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce26!=NULL)) { +var27 = varonce26; } else { -var30 = "int "; -var31 = 4; -var32 = standard___standard__NativeString___to_s_with_length(var30, var31); -var29 = var32; -varonce28 = var29; +var28 = "int "; +var29 = standard___standard__NativeString___to_s_with_length(var28, 4l); +var27 = var29; +varonce26 = var27; } -if (varonce33) { -var34 = varonce33; +((struct instance_standard__NativeArray*)var25)->values[0]=var27; +if (likely(varonce30!=NULL)) { +var31 = varonce30; } else { -var35 = ";"; -var36 = 1; -var37 = standard___standard__NativeString___to_s_with_length(var35, var36); -var34 = var37; -varonce33 = var34; -} -var38 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var38 = array_instance Array[Object] */ -var39 = 3; -var40 = NEW_standard__NativeArray(var39, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var40)->values[0] = (val*) var29; -((struct instance_standard__NativeArray*)var40)->values[1] = (val*) var_cltype; -((struct instance_standard__NativeArray*)var40)->values[2] = (val*) var34; -{ -((void (*)(val* self, val* p0, long p1))(var38->class->vft[COLOR_standard__array__Array__with_native]))(var38, var40, var39) /* with_native on */; +var32 = ";"; +var33 = standard___standard__NativeString___to_s_with_length(var32, 1l); +var31 = var33; +varonce30 = var31; } +((struct instance_standard__NativeArray*)var25)->values[2]=var31; +} else { +var25 = varonce24; +varonce24 = NULL; } +((struct instance_standard__NativeArray*)var25)->values[1]=var_cltype; { -var41 = ((val* (*)(val* self))(var38->class->vft[COLOR_standard__string__Object__to_s]))(var38) /* to_s on */; +var34 = ((val*(*)(val* self))(var25->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var25); /* native_to_s on */ } +varonce24 = var25; { -nit___nit__AbstractCompilerVisitor___add_decl(self, var41); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +nit___nit__AbstractCompilerVisitor___add_decl(self, var34); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } -if (varonce42) { -var43 = varonce42; +if (likely(varonce35!=NULL)) { +var36 = varonce35; } else { -var44 = "idtype"; -var45 = 6; -var46 = standard___standard__NativeString___to_s_with_length(var44, var45); -var43 = var46; -varonce42 = var43; +var37 = "idtype"; +var38 = standard___standard__NativeString___to_s_with_length(var37, 6l); +var36 = var38; +varonce35 = var36; } { -var47 = nit___nit__AbstractCompilerVisitor___get_name(self, var43); +var39 = nit___nit__AbstractCompilerVisitor___get_name(self, var36); } -var_idtype = var47; -if (varonce48) { -var49 = varonce48; +var_idtype = var39; +if (unlikely(varonce40==NULL)) { +var41 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce42!=NULL)) { +var43 = varonce42; } else { -var50 = "int "; -var51 = 4; -var52 = standard___standard__NativeString___to_s_with_length(var50, var51); -var49 = var52; -varonce48 = var49; +var44 = "int "; +var45 = standard___standard__NativeString___to_s_with_length(var44, 4l); +var43 = var45; +varonce42 = var43; } -if (varonce53) { -var54 = varonce53; +((struct instance_standard__NativeArray*)var41)->values[0]=var43; +if (likely(varonce46!=NULL)) { +var47 = varonce46; } else { -var55 = ";"; -var56 = 1; -var57 = standard___standard__NativeString___to_s_with_length(var55, var56); -var54 = var57; -varonce53 = var54; -} -var58 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var58 = array_instance Array[Object] */ -var59 = 3; -var60 = NEW_standard__NativeArray(var59, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var60)->values[0] = (val*) var49; -((struct instance_standard__NativeArray*)var60)->values[1] = (val*) var_idtype; -((struct instance_standard__NativeArray*)var60)->values[2] = (val*) var54; -{ -((void (*)(val* self, val* p0, long p1))(var58->class->vft[COLOR_standard__array__Array__with_native]))(var58, var60, var59) /* with_native on */; +var48 = ";"; +var49 = standard___standard__NativeString___to_s_with_length(var48, 1l); +var47 = var49; +varonce46 = var47; } +((struct instance_standard__NativeArray*)var41)->values[2]=var47; +} else { +var41 = varonce40; +varonce40 = NULL; } +((struct instance_standard__NativeArray*)var41)->values[1]=var_idtype; { -var61 = ((val* (*)(val* self))(var58->class->vft[COLOR_standard__string__Object__to_s]))(var58) /* to_s on */; +var50 = ((val*(*)(val* self))(var41->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var41); /* native_to_s on */ } +varonce40 = var41; { -nit___nit__AbstractCompilerVisitor___add_decl(self, var61); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +nit___nit__AbstractCompilerVisitor___add_decl(self, var50); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } { -var62 = nit___nit__SeparateCompilerVisitor___maybe_null(self, var_value); +var51 = nit___nit__SeparateCompilerVisitor___maybe_null(self, var_value); } -var_maybe_null = var62; -if (varonce63) { -var64 = varonce63; +var_maybe_null = var51; +if (likely(varonce52!=NULL)) { +var53 = varonce52; } else { -var65 = "0"; -var66 = 1; -var67 = standard___standard__NativeString___to_s_with_length(var65, var66); -var64 = var67; -varonce63 = var64; +var54 = "0"; +var55 = standard___standard__NativeString___to_s_with_length(var54, 1l); +var53 = var55; +varonce52 = var53; } -var_accept_null = var64; +var_accept_null = var53; /* isa MNullableType */ cltype = type_nit__MNullableType.color; idtype = type_nit__MNullableType.id; if(cltype >= var_mtype->type->table_size) { -var68 = 0; +var56 = 0; } else { -var68 = var_mtype->type->type_table[cltype] == idtype; +var56 = var_mtype->type->type_table[cltype] == idtype; } -if (var68){ +if (var56){ { -{ /* Inline model#MNullableType#mtype (var_mtype) on */ -var71 = var_mtype->attrs[COLOR_nit__model__MNullableType___mtype].val; /* _mtype on */ -if (unlikely(var71 == NULL)) { +{ /* Inline model#MProxyType#mtype (var_mtype) on */ +var59 = var_mtype->attrs[COLOR_nit__model__MProxyType___mtype].val; /* _mtype on */ +if (unlikely(var59 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1506); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1598); +fatal_exit(1); } -var69 = var71; -RET_LABEL70:(void)0; +var57 = var59; +RET_LABEL58:(void)0; } } -var_mtype = var69; -if (varonce72) { -var73 = varonce72; +var_mtype = var57; +if (likely(varonce60!=NULL)) { +var61 = varonce60; } else { -var74 = "1"; -var75 = 1; -var76 = standard___standard__NativeString___to_s_with_length(var74, var75); -var73 = var76; -varonce72 = var73; +var62 = "1"; +var63 = standard___standard__NativeString___to_s_with_length(var62, 1l); +var61 = var63; +varonce60 = var61; } -var_accept_null = var73; +var_accept_null = var61; } else { } /* isa MParameterType */ -cltype78 = type_nit__MParameterType.color; -idtype79 = type_nit__MParameterType.id; -if(cltype78 >= var_mtype->type->table_size) { -var77 = 0; +cltype65 = type_nit__MParameterType.color; +idtype66 = type_nit__MParameterType.id; +if(cltype65 >= var_mtype->type->table_size) { +var64 = 0; } else { -var77 = var_mtype->type->type_table[cltype78] == idtype79; +var64 = var_mtype->type->type_table[cltype65] == idtype66; } -if (var77){ +if (var64){ { { /* Inline abstract_compiler#AbstractCompilerVisitor#frame (self) on */ -var82 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ -var80 = var82; -RET_LABEL81:(void)0; +var69 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ +var67 = var69; +RET_LABEL68:(void)0; } } -if (var80 == NULL) { +if (var67 == NULL) { PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 510); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 521); +fatal_exit(1); } else { -{ /* Inline abstract_compiler#StaticFrame#mpropdef (var80) on */ -if (unlikely(var80 == NULL)) { +{ /* Inline abstract_compiler#StaticFrame#mpropdef (var67) on */ +if (unlikely(var67 == NULL)) { PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1724); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1828); +fatal_exit(1); } -var85 = var80->attrs[COLOR_nit__abstract_compiler__StaticFrame___mpropdef].val; /* _mpropdef on */ -if (unlikely(var85 == NULL)) { +var72 = var67->attrs[COLOR_nit__abstract_compiler__StaticFrame___mpropdef].val; /* _mpropdef on */ +if (unlikely(var72 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1724); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1828); +fatal_exit(1); } -var83 = var85; -RET_LABEL84:(void)0; +var70 = var72; +RET_LABEL71:(void)0; } } { -{ /* Inline model#MPropDef#mclassdef (var83) on */ -var88 = var83->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ -if (unlikely(var88 == NULL)) { +{ /* Inline model#MPropDef#mclassdef (var70) on */ +var75 = var70->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var75 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2010); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2209); +fatal_exit(1); } -var86 = var88; -RET_LABEL87:(void)0; +var73 = var75; +RET_LABEL74:(void)0; } } { -{ /* Inline model#MClassDef#bound_mtype (var86) on */ -var91 = var86->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ -if (unlikely(var91 == NULL)) { +{ /* Inline model#MClassDef#bound_mtype (var73) on */ +var78 = var73->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ +if (unlikely(var78 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 495); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 556); +fatal_exit(1); } -var89 = var91; -RET_LABEL90:(void)0; +var76 = var78; +RET_LABEL77:(void)0; } } { { /* Inline abstract_compiler#AbstractCompilerVisitor#frame (self) on */ -var94 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ -var92 = var94; -RET_LABEL93:(void)0; +var81 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ +var79 = var81; +RET_LABEL80:(void)0; } } -if (var92 == NULL) { +if (var79 == NULL) { PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 510); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 521); +fatal_exit(1); } else { -{ /* Inline abstract_compiler#StaticFrame#mpropdef (var92) on */ -if (unlikely(var92 == NULL)) { +{ /* Inline abstract_compiler#StaticFrame#mpropdef (var79) on */ +if (unlikely(var79 == NULL)) { PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1724); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1828); +fatal_exit(1); } -var97 = var92->attrs[COLOR_nit__abstract_compiler__StaticFrame___mpropdef].val; /* _mpropdef on */ -if (unlikely(var97 == NULL)) { +var84 = var79->attrs[COLOR_nit__abstract_compiler__StaticFrame___mpropdef].val; /* _mpropdef on */ +if (unlikely(var84 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1724); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1828); +fatal_exit(1); } -var95 = var97; -RET_LABEL96:(void)0; +var82 = var84; +RET_LABEL83:(void)0; } } { -{ /* Inline model#MPropDef#mclassdef (var95) on */ -var100 = var95->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ -if (unlikely(var100 == NULL)) { +{ /* Inline model#MPropDef#mclassdef (var82) on */ +var87 = var82->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var87 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2010); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2209); +fatal_exit(1); } -var98 = var100; -RET_LABEL99:(void)0; +var85 = var87; +RET_LABEL86:(void)0; } } { -{ /* Inline model#MClassDef#bound_mtype (var98) on */ -var103 = var98->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ -if (unlikely(var103 == NULL)) { +{ /* Inline model#MClassDef#bound_mtype (var85) on */ +var90 = var85->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ +if (unlikely(var90 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 495); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 556); +fatal_exit(1); } -var101 = var103; -RET_LABEL102:(void)0; +var88 = var90; +RET_LABEL89:(void)0; } } { { /* Inline abstract_compiler#AbstractCompilerVisitor#frame (self) on */ -var106 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ -var104 = var106; -RET_LABEL105:(void)0; +var93 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ +var91 = var93; +RET_LABEL92:(void)0; } } -if (var104 == NULL) { +if (var91 == NULL) { PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 510); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 521); +fatal_exit(1); } else { -{ /* Inline abstract_compiler#StaticFrame#mpropdef (var104) on */ -if (unlikely(var104 == NULL)) { +{ /* Inline abstract_compiler#StaticFrame#mpropdef (var91) on */ +if (unlikely(var91 == NULL)) { PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1724); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1828); +fatal_exit(1); } -var109 = var104->attrs[COLOR_nit__abstract_compiler__StaticFrame___mpropdef].val; /* _mpropdef on */ -if (unlikely(var109 == NULL)) { +var96 = var91->attrs[COLOR_nit__abstract_compiler__StaticFrame___mpropdef].val; /* _mpropdef on */ +if (unlikely(var96 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1724); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1828); +fatal_exit(1); } -var107 = var109; -RET_LABEL108:(void)0; +var94 = var96; +RET_LABEL95:(void)0; } } { -{ /* Inline model#MPropDef#mclassdef (var107) on */ -var112 = var107->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ -if (unlikely(var112 == NULL)) { +{ /* Inline model#MPropDef#mclassdef (var94) on */ +var99 = var94->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var99 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2010); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2209); +fatal_exit(1); } -var110 = var112; -RET_LABEL111:(void)0; +var97 = var99; +RET_LABEL98:(void)0; } } { -{ /* Inline model#MClassDef#mmodule (var110) on */ -var115 = var110->attrs[COLOR_nit__model__MClassDef___mmodule].val; /* _mmodule on */ -if (unlikely(var115 == NULL)) { +{ /* Inline model#MClassDef#mmodule (var97) on */ +var102 = var97->attrs[COLOR_nit__model__MClassDef___mmodule].val; /* _mmodule on */ +if (unlikely(var102 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mmodule"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 489); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 550); +fatal_exit(1); } -var113 = var115; -RET_LABEL114:(void)0; +var100 = var102; +RET_LABEL101:(void)0; } } -var116 = 0; { -var117 = nit___nit__MParameterType___MType__resolve_for(var_mtype, var89, var101, var113, var116); +var103 = nit___nit__MParameterType___MType__resolve_for(var_mtype, var76, var88, var100, 0); } -var_mtype = var117; +var_mtype = var103; /* isa MNullableType */ -cltype119 = type_nit__MNullableType.color; -idtype120 = type_nit__MNullableType.id; -if(cltype119 >= var_mtype->type->table_size) { -var118 = 0; +cltype105 = type_nit__MNullableType.color; +idtype106 = type_nit__MNullableType.id; +if(cltype105 >= var_mtype->type->table_size) { +var104 = 0; } else { -var118 = var_mtype->type->type_table[cltype119] == idtype120; +var104 = var_mtype->type->type_table[cltype105] == idtype106; } -if (var118){ +if (var104){ { -{ /* Inline model#MNullableType#mtype (var_mtype) on */ -var123 = var_mtype->attrs[COLOR_nit__model__MNullableType___mtype].val; /* _mtype on */ -if (unlikely(var123 == NULL)) { +{ /* Inline model#MProxyType#mtype (var_mtype) on */ +var109 = var_mtype->attrs[COLOR_nit__model__MProxyType___mtype].val; /* _mtype on */ +if (unlikely(var109 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1506); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1598); +fatal_exit(1); } -var121 = var123; -RET_LABEL122:(void)0; +var107 = var109; +RET_LABEL108:(void)0; } } -var_mtype = var121; -if (varonce124) { -var125 = varonce124; +var_mtype = var107; +if (likely(varonce110!=NULL)) { +var111 = varonce110; } else { -var126 = "1"; -var127 = 1; -var128 = standard___standard__NativeString___to_s_with_length(var126, var127); -var125 = var128; -varonce124 = var125; +var112 = "1"; +var113 = standard___standard__NativeString___to_s_with_length(var112, 1l); +var111 = var113; +varonce110 = var111; } -var_accept_null = var125; +var_accept_null = var111; } else { } } else { } { { /* Inline abstract_compiler#RuntimeVariable#mcasttype (var_value) on */ -var131 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mcasttype].val; /* _mcasttype on */ -if (unlikely(var131 == NULL)) { +var116 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mcasttype].val; /* _mcasttype on */ +if (unlikely(var116 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mcasttype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1683); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1787); +fatal_exit(1); } -var129 = var131; -RET_LABEL130:(void)0; +var114 = var116; +RET_LABEL115:(void)0; } } { { /* Inline abstract_compiler#AbstractCompilerVisitor#frame (self) on */ -var134 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ -var132 = var134; -RET_LABEL133:(void)0; +var119 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ +var117 = var119; +RET_LABEL118:(void)0; } } -if (var132 == NULL) { +if (var117 == NULL) { PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 517); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 528); +fatal_exit(1); } else { -{ /* Inline abstract_compiler#StaticFrame#mpropdef (var132) on */ -if (unlikely(var132 == NULL)) { +{ /* Inline abstract_compiler#StaticFrame#mpropdef (var117) on */ +if (unlikely(var117 == NULL)) { PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1724); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1828); +fatal_exit(1); } -var137 = var132->attrs[COLOR_nit__abstract_compiler__StaticFrame___mpropdef].val; /* _mpropdef on */ -if (unlikely(var137 == NULL)) { +var122 = var117->attrs[COLOR_nit__abstract_compiler__StaticFrame___mpropdef].val; /* _mpropdef on */ +if (unlikely(var122 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1724); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1828); +fatal_exit(1); } -var135 = var137; -RET_LABEL136:(void)0; +var120 = var122; +RET_LABEL121:(void)0; } } { -{ /* Inline model#MPropDef#mclassdef (var135) on */ -var140 = var135->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ -if (unlikely(var140 == NULL)) { +{ /* Inline model#MPropDef#mclassdef (var120) on */ +var125 = var120->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var125 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2010); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2209); +fatal_exit(1); } -var138 = var140; -RET_LABEL139:(void)0; +var123 = var125; +RET_LABEL124:(void)0; } } { -{ /* Inline model#MClassDef#mmodule (var138) on */ -var143 = var138->attrs[COLOR_nit__model__MClassDef___mmodule].val; /* _mmodule on */ -if (unlikely(var143 == NULL)) { +{ /* Inline model#MClassDef#mmodule (var123) on */ +var128 = var123->attrs[COLOR_nit__model__MClassDef___mmodule].val; /* _mmodule on */ +if (unlikely(var128 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mmodule"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 489); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 550); +fatal_exit(1); } -var141 = var143; -RET_LABEL142:(void)0; +var126 = var128; +RET_LABEL127:(void)0; } } { { /* Inline abstract_compiler#AbstractCompilerVisitor#frame (self) on */ -var146 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ -var144 = var146; -RET_LABEL145:(void)0; +var131 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ +var129 = var131; +RET_LABEL130:(void)0; } } -if (var144 == NULL) { +if (var129 == NULL) { PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 517); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 528); +fatal_exit(1); } else { -{ /* Inline abstract_compiler#StaticFrame#mpropdef (var144) on */ -if (unlikely(var144 == NULL)) { +{ /* Inline abstract_compiler#StaticFrame#mpropdef (var129) on */ +if (unlikely(var129 == NULL)) { PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1724); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1828); +fatal_exit(1); } -var149 = var144->attrs[COLOR_nit__abstract_compiler__StaticFrame___mpropdef].val; /* _mpropdef on */ -if (unlikely(var149 == NULL)) { +var134 = var129->attrs[COLOR_nit__abstract_compiler__StaticFrame___mpropdef].val; /* _mpropdef on */ +if (unlikely(var134 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1724); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1828); +fatal_exit(1); } -var147 = var149; -RET_LABEL148:(void)0; +var132 = var134; +RET_LABEL133:(void)0; } } { -{ /* Inline model#MPropDef#mclassdef (var147) on */ -var152 = var147->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ -if (unlikely(var152 == NULL)) { +{ /* Inline model#MPropDef#mclassdef (var132) on */ +var137 = var132->attrs[COLOR_nit__model__MPropDef___mclassdef].val; /* _mclassdef on */ +if (unlikely(var137 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2010); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 2209); +fatal_exit(1); } -var150 = var152; -RET_LABEL151:(void)0; +var135 = var137; +RET_LABEL136:(void)0; } } { -{ /* Inline model#MClassDef#bound_mtype (var150) on */ -var155 = var150->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ -if (unlikely(var155 == NULL)) { +{ /* Inline model#MClassDef#bound_mtype (var135) on */ +var140 = var135->attrs[COLOR_nit__model__MClassDef___bound_mtype].val; /* _bound_mtype on */ +if (unlikely(var140 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 495); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 556); +fatal_exit(1); } -var153 = var155; -RET_LABEL154:(void)0; +var138 = var140; +RET_LABEL139:(void)0; } } { -var156 = nit___nit__MType___is_subtype(var129, var141, var153, var_mtype); +var141 = nit___nit__MType___is_subtype(var114, var126, var138, var_mtype); } -if (var156){ -if (varonce157) { -var158 = varonce157; +if (var141){ +if (unlikely(varonce142==NULL)) { +var143 = NEW_standard__NativeArray(6l, &type_standard__NativeArray__standard__String); +if (likely(varonce144!=NULL)) { +var145 = varonce144; } else { -var159 = " = 1; /* easy "; -var160 = 14; -var161 = standard___standard__NativeString___to_s_with_length(var159, var160); -var158 = var161; -varonce157 = var158; +var146 = " = 1; /* easy "; +var147 = standard___standard__NativeString___to_s_with_length(var146, 14l); +var145 = var147; +varonce144 = var145; } -{ -var162 = nit___nit__RuntimeVariable___standard__string__Object__inspect(var_value); +((struct instance_standard__NativeArray*)var143)->values[1]=var145; +if (likely(varonce148!=NULL)) { +var149 = varonce148; +} else { +var150 = " isa "; +var151 = standard___standard__NativeString___to_s_with_length(var150, 5l); +var149 = var151; +varonce148 = var149; } -if (varonce163) { -var164 = varonce163; +((struct instance_standard__NativeArray*)var143)->values[3]=var149; +if (likely(varonce152!=NULL)) { +var153 = varonce152; } else { -var165 = " isa "; -var166 = 5; -var167 = standard___standard__NativeString___to_s_with_length(var165, var166); -var164 = var167; -varonce163 = var164; +var154 = "*/"; +var155 = standard___standard__NativeString___to_s_with_length(var154, 2l); +var153 = var155; +varonce152 = var153; } -if (varonce168) { -var169 = varonce168; +((struct instance_standard__NativeArray*)var143)->values[5]=var153; } else { -var170 = "*/"; -var171 = 2; -var172 = standard___standard__NativeString___to_s_with_length(var170, var171); -var169 = var172; -varonce168 = var169; +var143 = varonce142; +varonce142 = NULL; } -var173 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var173 = array_instance Array[Object] */ -var174 = 6; -var175 = NEW_standard__NativeArray(var174, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var175)->values[0] = (val*) var_res; -((struct instance_standard__NativeArray*)var175)->values[1] = (val*) var158; -((struct instance_standard__NativeArray*)var175)->values[2] = (val*) var162; -((struct instance_standard__NativeArray*)var175)->values[3] = (val*) var164; -((struct instance_standard__NativeArray*)var175)->values[4] = (val*) var_mtype; -((struct instance_standard__NativeArray*)var175)->values[5] = (val*) var169; { -((void (*)(val* self, val* p0, long p1))(var173->class->vft[COLOR_standard__array__Array__with_native]))(var173, var175, var174) /* with_native on */; +var156 = ((val*(*)(val* self))(var_res->class->vft[COLOR_standard__string__Object__to_s]))(var_res); /* to_s on */ } +((struct instance_standard__NativeArray*)var143)->values[0]=var156; +{ +var157 = nit___nit__RuntimeVariable___standard__string__Object__inspect(var_value); +} +((struct instance_standard__NativeArray*)var143)->values[2]=var157; +{ +var158 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_standard__string__Object__to_s]))(var_mtype); /* to_s on */ } +((struct instance_standard__NativeArray*)var143)->values[4]=var158; { -var176 = ((val* (*)(val* self))(var173->class->vft[COLOR_standard__string__Object__to_s]))(var173) /* to_s on */; +var159 = ((val*(*)(val* self))(var143->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var143); /* native_to_s on */ } +varonce142 = var143; { -nit___nit__AbstractCompilerVisitor___add(self, var176); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var159); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } { { /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on */ -var179 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ -if (unlikely(var179 == NULL)) { +var162 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ +if (unlikely(var162 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1059); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1102); +fatal_exit(1); } -var177 = var179; -RET_LABEL178:(void)0; +var160 = var162; +RET_LABEL161:(void)0; } } { -{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (var177) on */ -var182 = var177->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ -if (unlikely(var182 == NULL)) { +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (var160) on */ +var165 = var160->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var165 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 522); +fatal_exit(1); } -var180 = var182; -RET_LABEL181:(void)0; +var163 = var165; +RET_LABEL164:(void)0; } } { -{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var180) on */ -var185 = var180->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ -if (unlikely(var185 == NULL)) { +{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var163) on */ +var168 = var163->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ +if (unlikely(var168 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47); -show_backtrace(1); +fatal_exit(1); } -var183 = var185; -RET_LABEL184:(void)0; +var166 = var168; +RET_LABEL167:(void)0; } } { -{ /* Inline abstract_compiler#ToolContext#opt_typing_test_metrics (var183) on */ -var188 = var183->attrs[COLOR_nit__abstract_compiler__ToolContext___opt_typing_test_metrics].val; /* _opt_typing_test_metrics on */ -if (unlikely(var188 == NULL)) { +{ /* Inline abstract_compiler#ToolContext#opt_typing_test_metrics (var166) on */ +var171 = var166->attrs[COLOR_nit__abstract_compiler__ToolContext___opt_typing_test_metrics].val; /* _opt_typing_test_metrics on */ +if (unlikely(var171 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_typing_test_metrics"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 59); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 60); +fatal_exit(1); } -var186 = var188; -RET_LABEL187:(void)0; +var169 = var171; +RET_LABEL170:(void)0; } } { -{ /* Inline opts#Option#value (var186) on */ -var191 = var186->attrs[COLOR_opts__Option___value].val; /* _value on */ -var189 = var191; -RET_LABEL190:(void)0; +{ /* Inline opts#Option#value (var169) on */ +var174 = var169->attrs[COLOR_opts__Option___value].val; /* _value on */ +var172 = var174; +RET_LABEL173:(void)0; } } -var192 = ((struct instance_standard__Bool*)var189)->value; /* autounbox from nullable Object to Bool */; -if (var192){ +var175 = (short int)((long)(var172)>>2); +if (var175){ { { /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on */ -var195 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ -if (unlikely(var195 == NULL)) { +var178 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ +if (unlikely(var178 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1059); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1102); +fatal_exit(1); } -var193 = var195; -RET_LABEL194:(void)0; +var176 = var178; +RET_LABEL177:(void)0; } } { -{ /* Inline abstract_compiler#AbstractCompiler#count_type_test_skipped (var193) on */ -var198 = var193->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___count_type_test_skipped].val; /* _count_type_test_skipped on */ -if (unlikely(var198 == NULL)) { +{ /* Inline abstract_compiler#AbstractCompiler#count_type_test_skipped (var176) on */ +var181 = var176->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___count_type_test_skipped].val; /* _count_type_test_skipped on */ +if (unlikely(var181 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _count_type_test_skipped"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 966); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1017); +fatal_exit(1); } -var196 = var198; -RET_LABEL197:(void)0; +var179 = var181; +RET_LABEL180:(void)0; } } -var_ = var196; -var_199 = var_tag; +var_ = var179; +var_182 = var_tag; { -var200 = standard___standard__HashMap___standard__abstract_collection__MapRead___91d_93d(var_, var_199); +var183 = standard___standard__HashMap___standard__abstract_collection__MapRead___91d_93d(var_, var_182); } -var201 = 1; { -{ /* Inline kernel#Int#+ (var200,var201) on */ -/* Covariant cast for argument 0 (i) isa OTHER */ -/* isa OTHER */ -var204 = 1; /* easy isa OTHER*/ -if (unlikely(!var204)) { +{ /* Inline kernel#Int#+ (var183,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var186 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var186)) { var_class_name = type_standard__Int.name; PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name); -PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 537); +fatal_exit(1); } -var207 = ((struct instance_standard__Int*)var200)->value; /* autounbox from nullable Object to Int */; -var208 = var207 + var201; -var202 = var208; -goto RET_LABEL203; -RET_LABEL203:(void)0; +var189 = (long)(var183)>>2; +var190 = var189 + 1l; +var184 = var190; +goto RET_LABEL185; +RET_LABEL185:(void)0; } } { -var209 = BOX_standard__Int(var202); /* autobox from Int to nullable Object */ -standard___standard__HashMap___standard__abstract_collection__Map___91d_93d_61d(var_, var_199, var209); /* Direct call hash_collection#HashMap#[]= on */ +var191 = (val*)(var184<<2|1); +standard___standard__HashMap___standard__abstract_collection__Map___91d_93d_61d(var_, var_182, var191); /* Direct call hash_collection#HashMap#[]= on */ } -if (varonce210) { -var211 = varonce210; +if (unlikely(varonce192==NULL)) { +var193 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce194!=NULL)) { +var195 = varonce194; } else { -var212 = "count_type_test_skipped_"; -var213 = 24; -var214 = standard___standard__NativeString___to_s_with_length(var212, var213); -var211 = var214; -varonce210 = var211; +var196 = "count_type_test_skipped_"; +var197 = standard___standard__NativeString___to_s_with_length(var196, 24l); +var195 = var197; +varonce194 = var195; } -if (varonce215) { -var216 = varonce215; +((struct instance_standard__NativeArray*)var193)->values[0]=var195; +if (likely(varonce198!=NULL)) { +var199 = varonce198; } else { -var217 = "++;"; -var218 = 3; -var219 = standard___standard__NativeString___to_s_with_length(var217, var218); -var216 = var219; -varonce215 = var216; -} -var220 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var220 = array_instance Array[Object] */ -var221 = 3; -var222 = NEW_standard__NativeArray(var221, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var222)->values[0] = (val*) var211; -((struct instance_standard__NativeArray*)var222)->values[1] = (val*) var_tag; -((struct instance_standard__NativeArray*)var222)->values[2] = (val*) var216; -{ -((void (*)(val* self, val* p0, long p1))(var220->class->vft[COLOR_standard__array__Array__with_native]))(var220, var222, var221) /* with_native on */; +var200 = "++;"; +var201 = standard___standard__NativeString___to_s_with_length(var200, 3l); +var199 = var201; +varonce198 = var199; } +((struct instance_standard__NativeArray*)var193)->values[2]=var199; +} else { +var193 = varonce192; +varonce192 = NULL; } +((struct instance_standard__NativeArray*)var193)->values[1]=var_tag; { -var223 = ((val* (*)(val* self))(var220->class->vft[COLOR_standard__string__Object__to_s]))(var220) /* to_s on */; +var202 = ((val*(*)(val* self))(var193->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var193); /* native_to_s on */ } +varonce192 = var193; { -nit___nit__AbstractCompilerVisitor___add(self, var223); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var202); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } } else { } @@ -1422,1416 +1306,1338 @@ goto RET_LABEL; } { { /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var226 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var226 == NULL)) { +var205 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var205 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1784); +fatal_exit(1); } -var224 = var226; -RET_LABEL225:(void)0; +var203 = var205; +RET_LABEL204:(void)0; } } { -var227 = ((val* (*)(val* self))(var224->class->vft[COLOR_nit__abstract_compiler__MType__ctype]))(var224) /* ctype on */; +var206 = ((short int(*)(val* self))(var203->class->vft[COLOR_nit__abstract_compiler__MType__is_c_primitive]))(var203); /* is_c_primitive on */ } -if (varonce228) { -var229 = varonce228; +var207 = !var206; +if (var207){ +if (unlikely(varonce208==NULL)) { +var209 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce210!=NULL)) { +var211 = varonce210; } else { -var230 = "val*"; -var231 = 4; -var232 = standard___standard__NativeString___to_s_with_length(var230, var231); -var229 = var232; -varonce228 = var229; -} -{ -var233 = ((short int (*)(val* self, val* p0))(var227->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var227, var229) /* == on */; +var212 = "->class->"; +var213 = standard___standard__NativeString___to_s_with_length(var212, 9l); +var211 = var213; +varonce210 = var211; } -if (var233){ -if (varonce234) { -var235 = varonce234; +((struct instance_standard__NativeArray*)var209)->values[1]=var211; } else { -var236 = "->class->"; -var237 = 9; -var238 = standard___standard__NativeString___to_s_with_length(var236, var237); -var235 = var238; -varonce234 = var235; +var209 = varonce208; +varonce208 = NULL; } -var239 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var239 = array_instance Array[Object] */ -var240 = 2; -var241 = NEW_standard__NativeArray(var240, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var241)->values[0] = (val*) var_value; -((struct instance_standard__NativeArray*)var241)->values[1] = (val*) var235; { -((void (*)(val* self, val* p0, long p1))(var239->class->vft[COLOR_standard__array__Array__with_native]))(var239, var241, var240) /* with_native on */; -} +var214 = ((val*(*)(val* self))(var_value->class->vft[COLOR_standard__string__Object__to_s]))(var_value); /* to_s on */ } +((struct instance_standard__NativeArray*)var209)->values[0]=var214; { -var242 = ((val* (*)(val* self))(var239->class->vft[COLOR_standard__string__Object__to_s]))(var239) /* to_s on */; +var215 = ((val*(*)(val* self))(var209->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var209); /* native_to_s on */ } -var_class_ptr = var242; +varonce208 = var209; +var_class_ptr = var215; } else { { { /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var245 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var245 == NULL)) { +var218 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var218 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1784); +fatal_exit(1); } -var243 = var245; -RET_LABEL244:(void)0; +var216 = var218; +RET_LABEL217:(void)0; } } -/* isa MClassType */ -cltype247 = type_nit__MClassType.color; -idtype248 = type_nit__MClassType.id; -if(cltype247 >= var243->type->table_size) { -var246 = 0; +/* isa MClassType */ +cltype220 = type_nit__MClassType.color; +idtype221 = type_nit__MClassType.id; +if(cltype220 >= var216->type->table_size) { +var219 = 0; } else { -var246 = var243->type->type_table[cltype247] == idtype248; +var219 = var216->type->type_table[cltype220] == idtype221; } -if (unlikely(!var246)) { -var_class_name249 = var243 == NULL ? "null" : var243->type->name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name249); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 530); -show_backtrace(1); +if (unlikely(!var219)) { +var_class_name222 = var216 == NULL ? "null" : var216->type->name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name222); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 541); +fatal_exit(1); } { -{ /* Inline model#MClassType#mclass (var243) on */ -var252 = var243->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var252 == NULL)) { +{ /* Inline model#MClassType#mclass (var216) on */ +var225 = var216->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var225 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1058); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138); +fatal_exit(1); } -var250 = var252; -RET_LABEL251:(void)0; +var223 = var225; +RET_LABEL224:(void)0; } } -var_mclass = var250; -if (varonce253) { -var254 = varonce253; +var_mclass = var223; +if (unlikely(varonce226==NULL)) { +var227 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce228!=NULL)) { +var229 = varonce228; } else { -var255 = "class_"; -var256 = 6; -var257 = standard___standard__NativeString___to_s_with_length(var255, var256); -var254 = var257; -varonce253 = var254; +var230 = "class_"; +var231 = standard___standard__NativeString___to_s_with_length(var230, 6l); +var229 = var231; +varonce228 = var229; } -{ -var258 = nit___nit__MClass___nit__model_base__MEntity__c_name(var_mclass); +((struct instance_standard__NativeArray*)var227)->values[0]=var229; +} else { +var227 = varonce226; +varonce226 = NULL; } -var259 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var259 = array_instance Array[Object] */ -var260 = 2; -var261 = NEW_standard__NativeArray(var260, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var261)->values[0] = (val*) var254; -((struct instance_standard__NativeArray*)var261)->values[1] = (val*) var258; { -((void (*)(val* self, val* p0, long p1))(var259->class->vft[COLOR_standard__array__Array__with_native]))(var259, var261, var260) /* with_native on */; -} +var232 = nit___nit__MClass___nit__model_base__MEntity__c_name(var_mclass); } +((struct instance_standard__NativeArray*)var227)->values[1]=var232; { -var262 = ((val* (*)(val* self))(var259->class->vft[COLOR_standard__string__Object__to_s]))(var259) /* to_s on */; +var233 = ((val*(*)(val* self))(var227->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var227); /* native_to_s on */ } +varonce226 = var227; { -nit___nit__AbstractCompilerVisitor___require_declaration(self, var262); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +nit___nit__AbstractCompilerVisitor___require_declaration(self, var233); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ } -if (varonce263) { -var264 = varonce263; +if (unlikely(varonce234==NULL)) { +var235 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce236!=NULL)) { +var237 = varonce236; } else { -var265 = "class_"; -var266 = 6; -var267 = standard___standard__NativeString___to_s_with_length(var265, var266); -var264 = var267; -varonce263 = var264; +var238 = "class_"; +var239 = standard___standard__NativeString___to_s_with_length(var238, 6l); +var237 = var239; +varonce236 = var237; } -{ -var268 = nit___nit__MClass___nit__model_base__MEntity__c_name(var_mclass); +((struct instance_standard__NativeArray*)var235)->values[0]=var237; +if (likely(varonce240!=NULL)) { +var241 = varonce240; +} else { +var242 = "."; +var243 = standard___standard__NativeString___to_s_with_length(var242, 1l); +var241 = var243; +varonce240 = var241; } -if (varonce269) { -var270 = varonce269; +((struct instance_standard__NativeArray*)var235)->values[2]=var241; } else { -var271 = "."; -var272 = 1; -var273 = standard___standard__NativeString___to_s_with_length(var271, var272); -var270 = var273; -varonce269 = var270; +var235 = varonce234; +varonce234 = NULL; } -var274 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var274 = array_instance Array[Object] */ -var275 = 3; -var276 = NEW_standard__NativeArray(var275, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var276)->values[0] = (val*) var264; -((struct instance_standard__NativeArray*)var276)->values[1] = (val*) var268; -((struct instance_standard__NativeArray*)var276)->values[2] = (val*) var270; { -((void (*)(val* self, val* p0, long p1))(var274->class->vft[COLOR_standard__array__Array__with_native]))(var274, var276, var275) /* with_native on */; -} +var244 = nit___nit__MClass___nit__model_base__MEntity__c_name(var_mclass); } +((struct instance_standard__NativeArray*)var235)->values[1]=var244; { -var277 = ((val* (*)(val* self))(var274->class->vft[COLOR_standard__string__Object__to_s]))(var274) /* to_s on */; +var245 = ((val*(*)(val* self))(var235->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var235); /* native_to_s on */ } -var_class_ptr = var277; +varonce234 = var235; +var_class_ptr = var245; } /* isa MClassType */ -cltype279 = type_nit__MClassType.color; -idtype280 = type_nit__MClassType.id; -if(cltype279 >= var_mtype->type->table_size) { -var278 = 0; +cltype247 = type_nit__MClassType.color; +idtype248 = type_nit__MClassType.id; +if(cltype247 >= var_mtype->type->table_size) { +var246 = 0; } else { -var278 = var_mtype->type->type_table[cltype279] == idtype280; +var246 = var_mtype->type->type_table[cltype247] == idtype248; } -if (var278){ -if (varonce281) { -var282 = varonce281; +if (var246){ +if (unlikely(varonce249==NULL)) { +var250 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce251!=NULL)) { +var252 = varonce251; } else { -var283 = "class_"; -var284 = 6; -var285 = standard___standard__NativeString___to_s_with_length(var283, var284); -var282 = var285; -varonce281 = var282; +var253 = "class_"; +var254 = standard___standard__NativeString___to_s_with_length(var253, 6l); +var252 = var254; +varonce251 = var252; +} +((struct instance_standard__NativeArray*)var250)->values[0]=var252; +} else { +var250 = varonce249; +varonce249 = NULL; } { { /* Inline model#MClassType#mclass (var_mtype) on */ -var288 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var288 == NULL)) { +var257 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var257 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1058); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138); +fatal_exit(1); } -var286 = var288; -RET_LABEL287:(void)0; +var255 = var257; +RET_LABEL256:(void)0; } } { -var289 = nit___nit__MClass___nit__model_base__MEntity__c_name(var286); +var258 = nit___nit__MClass___nit__model_base__MEntity__c_name(var255); } -var290 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var290 = array_instance Array[Object] */ -var291 = 2; -var292 = NEW_standard__NativeArray(var291, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var292)->values[0] = (val*) var282; -((struct instance_standard__NativeArray*)var292)->values[1] = (val*) var289; +((struct instance_standard__NativeArray*)var250)->values[1]=var258; { -((void (*)(val* self, val* p0, long p1))(var290->class->vft[COLOR_standard__array__Array__with_native]))(var290, var292, var291) /* with_native on */; -} +var259 = ((val*(*)(val* self))(var250->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var250); /* native_to_s on */ } +varonce249 = var250; { -var293 = ((val* (*)(val* self))(var290->class->vft[COLOR_standard__string__Object__to_s]))(var290) /* to_s on */; +nit___nit__AbstractCompilerVisitor___require_declaration(self, var259); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ } -{ -nit___nit__AbstractCompilerVisitor___require_declaration(self, var293); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +if (unlikely(varonce260==NULL)) { +var261 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce262!=NULL)) { +var263 = varonce262; +} else { +var264 = " = class_"; +var265 = standard___standard__NativeString___to_s_with_length(var264, 9l); +var263 = var265; +varonce262 = var263; } -if (varonce294) { -var295 = varonce294; +((struct instance_standard__NativeArray*)var261)->values[1]=var263; +if (likely(varonce266!=NULL)) { +var267 = varonce266; } else { -var296 = " = class_"; -var297 = 9; -var298 = standard___standard__NativeString___to_s_with_length(var296, var297); -var295 = var298; -varonce294 = var295; +var268 = ".color;"; +var269 = standard___standard__NativeString___to_s_with_length(var268, 7l); +var267 = var269; +varonce266 = var267; } +((struct instance_standard__NativeArray*)var261)->values[3]=var267; +} else { +var261 = varonce260; +varonce260 = NULL; +} +((struct instance_standard__NativeArray*)var261)->values[0]=var_cltype; { { /* Inline model#MClassType#mclass (var_mtype) on */ -var301 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var301 == NULL)) { +var272 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var272 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1058); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138); +fatal_exit(1); } -var299 = var301; -RET_LABEL300:(void)0; +var270 = var272; +RET_LABEL271:(void)0; } } { -var302 = nit___nit__MClass___nit__model_base__MEntity__c_name(var299); -} -if (varonce303) { -var304 = varonce303; -} else { -var305 = ".color;"; -var306 = 7; -var307 = standard___standard__NativeString___to_s_with_length(var305, var306); -var304 = var307; -varonce303 = var304; +var273 = nit___nit__MClass___nit__model_base__MEntity__c_name(var270); } -var308 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var308 = array_instance Array[Object] */ -var309 = 4; -var310 = NEW_standard__NativeArray(var309, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var310)->values[0] = (val*) var_cltype; -((struct instance_standard__NativeArray*)var310)->values[1] = (val*) var295; -((struct instance_standard__NativeArray*)var310)->values[2] = (val*) var302; -((struct instance_standard__NativeArray*)var310)->values[3] = (val*) var304; +((struct instance_standard__NativeArray*)var261)->values[2]=var273; { -((void (*)(val* self, val* p0, long p1))(var308->class->vft[COLOR_standard__array__Array__with_native]))(var308, var310, var309) /* with_native on */; -} +var274 = ((val*(*)(val* self))(var261->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var261); /* native_to_s on */ } +varonce260 = var261; { -var311 = ((val* (*)(val* self))(var308->class->vft[COLOR_standard__string__Object__to_s]))(var308) /* to_s on */; +nit___nit__AbstractCompilerVisitor___add(self, var274); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -{ -nit___nit__AbstractCompilerVisitor___add(self, var311); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +if (unlikely(varonce275==NULL)) { +var276 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce277!=NULL)) { +var278 = varonce277; +} else { +var279 = " = class_"; +var280 = standard___standard__NativeString___to_s_with_length(var279, 9l); +var278 = var280; +varonce277 = var278; +} +((struct instance_standard__NativeArray*)var276)->values[1]=var278; +if (likely(varonce281!=NULL)) { +var282 = varonce281; +} else { +var283 = ".id;"; +var284 = standard___standard__NativeString___to_s_with_length(var283, 4l); +var282 = var284; +varonce281 = var282; } -if (varonce312) { -var313 = varonce312; +((struct instance_standard__NativeArray*)var276)->values[3]=var282; } else { -var314 = " = class_"; -var315 = 9; -var316 = standard___standard__NativeString___to_s_with_length(var314, var315); -var313 = var316; -varonce312 = var313; +var276 = varonce275; +varonce275 = NULL; } +((struct instance_standard__NativeArray*)var276)->values[0]=var_idtype; { { /* Inline model#MClassType#mclass (var_mtype) on */ -var319 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var319 == NULL)) { +var287 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var287 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1058); -show_backtrace(1); -} -var317 = var319; -RET_LABEL318:(void)0; -} +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138); +fatal_exit(1); } -{ -var320 = nit___nit__MClass___nit__model_base__MEntity__c_name(var317); +var285 = var287; +RET_LABEL286:(void)0; } -if (varonce321) { -var322 = varonce321; -} else { -var323 = ".id;"; -var324 = 4; -var325 = standard___standard__NativeString___to_s_with_length(var323, var324); -var322 = var325; -varonce321 = var322; } -var326 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var326 = array_instance Array[Object] */ -var327 = 4; -var328 = NEW_standard__NativeArray(var327, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var328)->values[0] = (val*) var_idtype; -((struct instance_standard__NativeArray*)var328)->values[1] = (val*) var313; -((struct instance_standard__NativeArray*)var328)->values[2] = (val*) var320; -((struct instance_standard__NativeArray*)var328)->values[3] = (val*) var322; { -((void (*)(val* self, val* p0, long p1))(var326->class->vft[COLOR_standard__array__Array__with_native]))(var326, var328, var327) /* with_native on */; -} +var288 = nit___nit__MClass___nit__model_base__MEntity__c_name(var285); } +((struct instance_standard__NativeArray*)var276)->values[2]=var288; { -var329 = ((val* (*)(val* self))(var326->class->vft[COLOR_standard__string__Object__to_s]))(var326) /* to_s on */; +var289 = ((val*(*)(val* self))(var276->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var276); /* native_to_s on */ } +varonce275 = var276; { -nit___nit__AbstractCompilerVisitor___add(self, var329); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var289); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } { { /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on */ -var332 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ -if (unlikely(var332 == NULL)) { +var292 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ +if (unlikely(var292 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1059); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1102); +fatal_exit(1); } -var330 = var332; -RET_LABEL331:(void)0; +var290 = var292; +RET_LABEL291:(void)0; } } { -{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (var330) on */ -var335 = var330->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ -if (unlikely(var335 == NULL)) { +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (var290) on */ +var295 = var290->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var295 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 522); +fatal_exit(1); } -var333 = var335; -RET_LABEL334:(void)0; +var293 = var295; +RET_LABEL294:(void)0; } } { -{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var333) on */ -var338 = var333->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ -if (unlikely(var338 == NULL)) { +{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var293) on */ +var298 = var293->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ +if (unlikely(var298 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47); -show_backtrace(1); +fatal_exit(1); } -var336 = var338; -RET_LABEL337:(void)0; +var296 = var298; +RET_LABEL297:(void)0; } } { -{ /* Inline abstract_compiler#ToolContext#opt_typing_test_metrics (var336) on */ -var341 = var336->attrs[COLOR_nit__abstract_compiler__ToolContext___opt_typing_test_metrics].val; /* _opt_typing_test_metrics on */ -if (unlikely(var341 == NULL)) { +{ /* Inline abstract_compiler#ToolContext#opt_typing_test_metrics (var296) on */ +var301 = var296->attrs[COLOR_nit__abstract_compiler__ToolContext___opt_typing_test_metrics].val; /* _opt_typing_test_metrics on */ +if (unlikely(var301 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_typing_test_metrics"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 59); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 60); +fatal_exit(1); } -var339 = var341; -RET_LABEL340:(void)0; +var299 = var301; +RET_LABEL300:(void)0; } } { -{ /* Inline opts#Option#value (var339) on */ -var344 = var339->attrs[COLOR_opts__Option___value].val; /* _value on */ -var342 = var344; -RET_LABEL343:(void)0; +{ /* Inline opts#Option#value (var299) on */ +var304 = var299->attrs[COLOR_opts__Option___value].val; /* _value on */ +var302 = var304; +RET_LABEL303:(void)0; } } -var345 = ((struct instance_standard__Bool*)var342)->value; /* autounbox from nullable Object to Bool */; -if (var345){ +var305 = (short int)((long)(var302)>>2); +if (var305){ { { /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on */ -var348 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ -if (unlikely(var348 == NULL)) { +var308 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ +if (unlikely(var308 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1059); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1102); +fatal_exit(1); } -var346 = var348; -RET_LABEL347:(void)0; +var306 = var308; +RET_LABEL307:(void)0; } } { -{ /* Inline abstract_compiler#AbstractCompiler#count_type_test_resolved (var346) on */ -var351 = var346->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___count_type_test_resolved].val; /* _count_type_test_resolved on */ -if (unlikely(var351 == NULL)) { +{ /* Inline abstract_compiler#AbstractCompiler#count_type_test_resolved (var306) on */ +var311 = var306->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___count_type_test_resolved].val; /* _count_type_test_resolved on */ +if (unlikely(var311 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _count_type_test_resolved"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 964); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1015); +fatal_exit(1); } -var349 = var351; -RET_LABEL350:(void)0; +var309 = var311; +RET_LABEL310:(void)0; } } -var_352 = var349; -var_353 = var_tag; +var_312 = var309; +var_313 = var_tag; { -var354 = standard___standard__HashMap___standard__abstract_collection__MapRead___91d_93d(var_352, var_353); +var314 = standard___standard__HashMap___standard__abstract_collection__MapRead___91d_93d(var_312, var_313); } -var355 = 1; { -{ /* Inline kernel#Int#+ (var354,var355) on */ -/* Covariant cast for argument 0 (i) isa OTHER */ -/* isa OTHER */ -var358 = 1; /* easy isa OTHER*/ -if (unlikely(!var358)) { -var_class_name361 = type_standard__Int.name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name361); -PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413); -show_backtrace(1); +{ /* Inline kernel#Int#+ (var314,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var317 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var317)) { +var_class_name320 = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name320); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 537); +fatal_exit(1); } -var362 = ((struct instance_standard__Int*)var354)->value; /* autounbox from nullable Object to Int */; -var363 = var362 + var355; -var356 = var363; -goto RET_LABEL357; -RET_LABEL357:(void)0; +var321 = (long)(var314)>>2; +var322 = var321 + 1l; +var315 = var322; +goto RET_LABEL316; +RET_LABEL316:(void)0; } } { -var364 = BOX_standard__Int(var356); /* autobox from Int to nullable Object */ -standard___standard__HashMap___standard__abstract_collection__Map___91d_93d_61d(var_352, var_353, var364); /* Direct call hash_collection#HashMap#[]= on */ +var323 = (val*)(var315<<2|1); +standard___standard__HashMap___standard__abstract_collection__Map___91d_93d_61d(var_312, var_313, var323); /* Direct call hash_collection#HashMap#[]= on */ } -if (varonce365) { -var366 = varonce365; +if (unlikely(varonce324==NULL)) { +var325 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce326!=NULL)) { +var327 = varonce326; } else { -var367 = "count_type_test_resolved_"; -var368 = 25; -var369 = standard___standard__NativeString___to_s_with_length(var367, var368); -var366 = var369; -varonce365 = var366; +var328 = "count_type_test_resolved_"; +var329 = standard___standard__NativeString___to_s_with_length(var328, 25l); +var327 = var329; +varonce326 = var327; } -if (varonce370) { -var371 = varonce370; +((struct instance_standard__NativeArray*)var325)->values[0]=var327; +if (likely(varonce330!=NULL)) { +var331 = varonce330; } else { -var372 = "++;"; -var373 = 3; -var374 = standard___standard__NativeString___to_s_with_length(var372, var373); -var371 = var374; -varonce370 = var371; -} -var375 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var375 = array_instance Array[Object] */ -var376 = 3; -var377 = NEW_standard__NativeArray(var376, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var377)->values[0] = (val*) var366; -((struct instance_standard__NativeArray*)var377)->values[1] = (val*) var_tag; -((struct instance_standard__NativeArray*)var377)->values[2] = (val*) var371; -{ -((void (*)(val* self, val* p0, long p1))(var375->class->vft[COLOR_standard__array__Array__with_native]))(var375, var377, var376) /* with_native on */; +var332 = "++;"; +var333 = standard___standard__NativeString___to_s_with_length(var332, 3l); +var331 = var333; +varonce330 = var331; } +((struct instance_standard__NativeArray*)var325)->values[2]=var331; +} else { +var325 = varonce324; +varonce324 = NULL; } +((struct instance_standard__NativeArray*)var325)->values[1]=var_tag; { -var378 = ((val* (*)(val* self))(var375->class->vft[COLOR_standard__string__Object__to_s]))(var375) /* to_s on */; +var334 = ((val*(*)(val* self))(var325->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var325); /* native_to_s on */ } +varonce324 = var325; { -nit___nit__AbstractCompilerVisitor___add(self, var378); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var334); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } } else { } } else { /* isa MVirtualType */ -cltype380 = type_nit__MVirtualType.color; -idtype381 = type_nit__MVirtualType.id; -if(cltype380 >= var_mtype->type->table_size) { -var379 = 0; +cltype336 = type_nit__MVirtualType.color; +idtype337 = type_nit__MVirtualType.id; +if(cltype336 >= var_mtype->type->table_size) { +var335 = 0; } else { -var379 = var_mtype->type->type_table[cltype380] == idtype381; +var335 = var_mtype->type->type_table[cltype336] == idtype337; } -if (var379){ +if (var335){ { { /* Inline abstract_compiler#AbstractCompilerVisitor#frame (self) on */ -var384 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ -var382 = var384; -RET_LABEL383:(void)0; +var340 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___frame].val; /* _frame on */ +var338 = var340; +RET_LABEL339:(void)0; } } -if (var382 == NULL) { +if (var338 == NULL) { PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 544); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 555); +fatal_exit(1); } else { -{ /* Inline abstract_compiler#StaticFrame#arguments (var382) on */ -if (unlikely(var382 == NULL)) { +{ /* Inline abstract_compiler#StaticFrame#arguments (var338) on */ +if (unlikely(var338 == NULL)) { PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1731); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1835); +fatal_exit(1); } -var387 = var382->attrs[COLOR_nit__abstract_compiler__StaticFrame___arguments].val; /* _arguments on */ -if (unlikely(var387 == NULL)) { +var343 = var338->attrs[COLOR_nit__abstract_compiler__StaticFrame___arguments].val; /* _arguments on */ +if (unlikely(var343 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _arguments"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1731); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1835); +fatal_exit(1); } -var385 = var387; -RET_LABEL386:(void)0; +var341 = var343; +RET_LABEL342:(void)0; } } { -var388 = standard___standard__SequenceRead___Collection__first(var385); +var344 = standard___standard__SequenceRead___Collection__first(var341); } -var_recv = var388; +var_recv = var344; { { /* Inline abstract_compiler#RuntimeVariable#mtype (var_recv) on */ -var391 = var_recv->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var391 == NULL)) { +var347 = var_recv->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var347 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1784); +fatal_exit(1); } -var389 = var391; -RET_LABEL390:(void)0; +var345 = var347; +RET_LABEL346:(void)0; } } { -var392 = ((val* (*)(val* self))(var389->class->vft[COLOR_nit__abstract_compiler__MType__ctype]))(var389) /* ctype on */; +var348 = ((short int(*)(val* self))(var345->class->vft[COLOR_nit__abstract_compiler__MType__is_c_primitive]))(var345); /* is_c_primitive on */ } -if (varonce393) { -var394 = varonce393; +var349 = !var348; +if (var349){ +if (unlikely(varonce350==NULL)) { +var351 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce352!=NULL)) { +var353 = varonce352; } else { -var395 = "val*"; -var396 = 4; -var397 = standard___standard__NativeString___to_s_with_length(var395, var396); -var394 = var397; -varonce393 = var394; -} -{ -var398 = ((short int (*)(val* self, val* p0))(var392->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var392, var394) /* == on */; +var354 = "->class->"; +var355 = standard___standard__NativeString___to_s_with_length(var354, 9l); +var353 = var355; +varonce352 = var353; } -if (var398){ -if (varonce399) { -var400 = varonce399; +((struct instance_standard__NativeArray*)var351)->values[1]=var353; } else { -var401 = "->class->"; -var402 = 9; -var403 = standard___standard__NativeString___to_s_with_length(var401, var402); -var400 = var403; -varonce399 = var400; +var351 = varonce350; +varonce350 = NULL; } -var404 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var404 = array_instance Array[Object] */ -var405 = 2; -var406 = NEW_standard__NativeArray(var405, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var406)->values[0] = (val*) var_recv; -((struct instance_standard__NativeArray*)var406)->values[1] = (val*) var400; { -((void (*)(val* self, val* p0, long p1))(var404->class->vft[COLOR_standard__array__Array__with_native]))(var404, var406, var405) /* with_native on */; -} +var356 = ((val*(*)(val* self))(var_recv->class->vft[COLOR_standard__string__Object__to_s]))(var_recv); /* to_s on */ } +((struct instance_standard__NativeArray*)var351)->values[0]=var356; { -var407 = ((val* (*)(val* self))(var404->class->vft[COLOR_standard__string__Object__to_s]))(var404) /* to_s on */; +var357 = ((val*(*)(val* self))(var351->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var351); /* native_to_s on */ } -var_recv_ptr = var407; +varonce350 = var351; +var_recv_ptr = var357; } else { { { /* Inline abstract_compiler#RuntimeVariable#mtype (var_recv) on */ -var410 = var_recv->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var410 == NULL)) { +var360 = var_recv->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var360 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1784); +fatal_exit(1); } -var408 = var410; -RET_LABEL409:(void)0; +var358 = var360; +RET_LABEL359:(void)0; } } -/* isa MClassType */ -cltype412 = type_nit__MClassType.color; -idtype413 = type_nit__MClassType.id; -if(cltype412 >= var408->type->table_size) { -var411 = 0; +/* isa MClassType */ +cltype362 = type_nit__MClassType.color; +idtype363 = type_nit__MClassType.id; +if(cltype362 >= var358->type->table_size) { +var361 = 0; } else { -var411 = var408->type->type_table[cltype412] == idtype413; +var361 = var358->type->type_table[cltype362] == idtype363; } -if (unlikely(!var411)) { -var_class_name414 = var408 == NULL ? "null" : var408->type->name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name414); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 549); -show_backtrace(1); +if (unlikely(!var361)) { +var_class_name364 = var358 == NULL ? "null" : var358->type->name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name364); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 560); +fatal_exit(1); } { -{ /* Inline model#MClassType#mclass (var408) on */ -var417 = var408->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var417 == NULL)) { +{ /* Inline model#MClassType#mclass (var358) on */ +var367 = var358->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var367 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1058); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138); +fatal_exit(1); } -var415 = var417; -RET_LABEL416:(void)0; +var365 = var367; +RET_LABEL366:(void)0; } } -var_mclass418 = var415; -if (varonce419) { -var420 = varonce419; +var_mclass368 = var365; +if (unlikely(varonce369==NULL)) { +var370 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce371!=NULL)) { +var372 = varonce371; } else { -var421 = "class_"; -var422 = 6; -var423 = standard___standard__NativeString___to_s_with_length(var421, var422); -var420 = var423; -varonce419 = var420; +var373 = "class_"; +var374 = standard___standard__NativeString___to_s_with_length(var373, 6l); +var372 = var374; +varonce371 = var372; } -{ -var424 = nit___nit__MClass___nit__model_base__MEntity__c_name(var_mclass418); +((struct instance_standard__NativeArray*)var370)->values[0]=var372; +} else { +var370 = varonce369; +varonce369 = NULL; } -var425 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var425 = array_instance Array[Object] */ -var426 = 2; -var427 = NEW_standard__NativeArray(var426, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var427)->values[0] = (val*) var420; -((struct instance_standard__NativeArray*)var427)->values[1] = (val*) var424; { -((void (*)(val* self, val* p0, long p1))(var425->class->vft[COLOR_standard__array__Array__with_native]))(var425, var427, var426) /* with_native on */; -} +var375 = nit___nit__MClass___nit__model_base__MEntity__c_name(var_mclass368); } +((struct instance_standard__NativeArray*)var370)->values[1]=var375; { -var428 = ((val* (*)(val* self))(var425->class->vft[COLOR_standard__string__Object__to_s]))(var425) /* to_s on */; +var376 = ((val*(*)(val* self))(var370->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var370); /* native_to_s on */ } +varonce369 = var370; { -nit___nit__AbstractCompilerVisitor___require_declaration(self, var428); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +nit___nit__AbstractCompilerVisitor___require_declaration(self, var376); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ } -if (varonce429) { -var430 = varonce429; +if (unlikely(varonce377==NULL)) { +var378 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce379!=NULL)) { +var380 = varonce379; } else { -var431 = "class_"; -var432 = 6; -var433 = standard___standard__NativeString___to_s_with_length(var431, var432); -var430 = var433; -varonce429 = var430; +var381 = "class_"; +var382 = standard___standard__NativeString___to_s_with_length(var381, 6l); +var380 = var382; +varonce379 = var380; } -{ -var434 = nit___nit__MClass___nit__model_base__MEntity__c_name(var_mclass418); +((struct instance_standard__NativeArray*)var378)->values[0]=var380; +if (likely(varonce383!=NULL)) { +var384 = varonce383; +} else { +var385 = "."; +var386 = standard___standard__NativeString___to_s_with_length(var385, 1l); +var384 = var386; +varonce383 = var384; } -if (varonce435) { -var436 = varonce435; +((struct instance_standard__NativeArray*)var378)->values[2]=var384; } else { -var437 = "."; -var438 = 1; -var439 = standard___standard__NativeString___to_s_with_length(var437, var438); -var436 = var439; -varonce435 = var436; +var378 = varonce377; +varonce377 = NULL; } -var440 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var440 = array_instance Array[Object] */ -var441 = 3; -var442 = NEW_standard__NativeArray(var441, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var442)->values[0] = (val*) var430; -((struct instance_standard__NativeArray*)var442)->values[1] = (val*) var434; -((struct instance_standard__NativeArray*)var442)->values[2] = (val*) var436; { -((void (*)(val* self, val* p0, long p1))(var440->class->vft[COLOR_standard__array__Array__with_native]))(var440, var442, var441) /* with_native on */; -} +var387 = nit___nit__MClass___nit__model_base__MEntity__c_name(var_mclass368); } +((struct instance_standard__NativeArray*)var378)->values[1]=var387; { -var443 = ((val* (*)(val* self))(var440->class->vft[COLOR_standard__string__Object__to_s]))(var440) /* to_s on */; +var388 = ((val*(*)(val* self))(var378->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var378); /* native_to_s on */ } -var_recv_ptr = var443; +varonce377 = var378; +var_recv_ptr = var388; } -if (varonce444) { -var445 = varonce444; +if (likely(varonce389!=NULL)) { +var390 = varonce389; } else { -var446 = "entry"; -var447 = 5; -var448 = standard___standard__NativeString___to_s_with_length(var446, var447); -var445 = var448; -varonce444 = var445; +var391 = "entry"; +var392 = standard___standard__NativeString___to_s_with_length(var391, 5l); +var390 = var392; +varonce389 = var390; } { -var449 = nit___nit__AbstractCompilerVisitor___get_name(self, var445); +var393 = nit___nit__AbstractCompilerVisitor___get_name(self, var390); } -var_entry = var449; -if (varonce450) { -var451 = varonce450; +var_entry = var393; +if (unlikely(varonce394==NULL)) { +var395 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce396!=NULL)) { +var397 = varonce396; } else { -var452 = "struct vts_entry "; -var453 = 17; -var454 = standard___standard__NativeString___to_s_with_length(var452, var453); -var451 = var454; -varonce450 = var451; +var398 = "struct vts_entry "; +var399 = standard___standard__NativeString___to_s_with_length(var398, 17l); +var397 = var399; +varonce396 = var397; } -if (varonce455) { -var456 = varonce455; +((struct instance_standard__NativeArray*)var395)->values[0]=var397; +if (likely(varonce400!=NULL)) { +var401 = varonce400; } else { -var457 = ";"; -var458 = 1; -var459 = standard___standard__NativeString___to_s_with_length(var457, var458); -var456 = var459; -varonce455 = var456; -} -var460 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var460 = array_instance Array[Object] */ -var461 = 3; -var462 = NEW_standard__NativeArray(var461, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var462)->values[0] = (val*) var451; -((struct instance_standard__NativeArray*)var462)->values[1] = (val*) var_entry; -((struct instance_standard__NativeArray*)var462)->values[2] = (val*) var456; -{ -((void (*)(val* self, val* p0, long p1))(var460->class->vft[COLOR_standard__array__Array__with_native]))(var460, var462, var461) /* with_native on */; +var402 = ";"; +var403 = standard___standard__NativeString___to_s_with_length(var402, 1l); +var401 = var403; +varonce400 = var401; } +((struct instance_standard__NativeArray*)var395)->values[2]=var401; +} else { +var395 = varonce394; +varonce394 = NULL; } +((struct instance_standard__NativeArray*)var395)->values[1]=var_entry; { -var463 = ((val* (*)(val* self))(var460->class->vft[COLOR_standard__string__Object__to_s]))(var460) /* to_s on */; +var404 = ((val*(*)(val* self))(var395->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var395); /* native_to_s on */ } +varonce394 = var395; { -nit___nit__AbstractCompilerVisitor___add(self, var463); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var404); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } { { /* Inline model#MVirtualType#mproperty (var_mtype) on */ -var466 = var_mtype->attrs[COLOR_nit__model__MVirtualType___mproperty].val; /* _mproperty on */ -if (unlikely(var466 == NULL)) { +var407 = var_mtype->attrs[COLOR_nit__model__MVirtualType___mproperty].val; /* _mproperty on */ +if (unlikely(var407 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mproperty"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1254); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1344); +fatal_exit(1); } -var464 = var466; -RET_LABEL465:(void)0; +var405 = var407; +RET_LABEL406:(void)0; } } { -var467 = nit__separate_compiler___MEntity___const_color(var464); +var408 = nit__separate_compiler___MEntity___const_color(var405); } { -nit___nit__AbstractCompilerVisitor___require_declaration(self, var467); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +nit___nit__AbstractCompilerVisitor___require_declaration(self, var408); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ } -if (varonce468) { -var469 = varonce468; +if (unlikely(varonce409==NULL)) { +var410 = NEW_standard__NativeArray(6l, &type_standard__NativeArray__standard__String); +if (likely(varonce411!=NULL)) { +var412 = varonce411; } else { -var470 = " = "; -var471 = 3; -var472 = standard___standard__NativeString___to_s_with_length(var470, var471); -var469 = var472; -varonce468 = var469; +var413 = " = "; +var414 = standard___standard__NativeString___to_s_with_length(var413, 3l); +var412 = var414; +varonce411 = var412; } -if (varonce473) { -var474 = varonce473; +((struct instance_standard__NativeArray*)var410)->values[1]=var412; +if (likely(varonce415!=NULL)) { +var416 = varonce415; } else { -var475 = "vts_table->vts["; -var476 = 15; -var477 = standard___standard__NativeString___to_s_with_length(var475, var476); -var474 = var477; -varonce473 = var474; +var417 = "vts_table->vts["; +var418 = standard___standard__NativeString___to_s_with_length(var417, 15l); +var416 = var418; +varonce415 = var416; +} +((struct instance_standard__NativeArray*)var410)->values[3]=var416; +if (likely(varonce419!=NULL)) { +var420 = varonce419; +} else { +var421 = "];"; +var422 = standard___standard__NativeString___to_s_with_length(var421, 2l); +var420 = var422; +varonce419 = var420; +} +((struct instance_standard__NativeArray*)var410)->values[5]=var420; +} else { +var410 = varonce409; +varonce409 = NULL; } +((struct instance_standard__NativeArray*)var410)->values[0]=var_entry; +((struct instance_standard__NativeArray*)var410)->values[2]=var_recv_ptr; { { /* Inline model#MVirtualType#mproperty (var_mtype) on */ -var480 = var_mtype->attrs[COLOR_nit__model__MVirtualType___mproperty].val; /* _mproperty on */ -if (unlikely(var480 == NULL)) { +var425 = var_mtype->attrs[COLOR_nit__model__MVirtualType___mproperty].val; /* _mproperty on */ +if (unlikely(var425 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mproperty"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1254); -show_backtrace(1); -} -var478 = var480; -RET_LABEL479:(void)0; +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1344); +fatal_exit(1); } +var423 = var425; +RET_LABEL424:(void)0; } -{ -var481 = nit__separate_compiler___MEntity___const_color(var478); -} -if (varonce482) { -var483 = varonce482; -} else { -var484 = "];"; -var485 = 2; -var486 = standard___standard__NativeString___to_s_with_length(var484, var485); -var483 = var486; -varonce482 = var483; } -var487 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var487 = array_instance Array[Object] */ -var488 = 6; -var489 = NEW_standard__NativeArray(var488, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var489)->values[0] = (val*) var_entry; -((struct instance_standard__NativeArray*)var489)->values[1] = (val*) var469; -((struct instance_standard__NativeArray*)var489)->values[2] = (val*) var_recv_ptr; -((struct instance_standard__NativeArray*)var489)->values[3] = (val*) var474; -((struct instance_standard__NativeArray*)var489)->values[4] = (val*) var481; -((struct instance_standard__NativeArray*)var489)->values[5] = (val*) var483; { -((void (*)(val* self, val* p0, long p1))(var487->class->vft[COLOR_standard__array__Array__with_native]))(var487, var489, var488) /* with_native on */; -} +var426 = nit__separate_compiler___MEntity___const_color(var423); } +((struct instance_standard__NativeArray*)var410)->values[4]=var426; { -var490 = ((val* (*)(val* self))(var487->class->vft[COLOR_standard__string__Object__to_s]))(var487) /* to_s on */; +var427 = ((val*(*)(val* self))(var410->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var410); /* native_to_s on */ } +varonce409 = var410; { -nit___nit__AbstractCompilerVisitor___add(self, var490); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var427); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce491) { -var492 = varonce491; +if (unlikely(varonce428==NULL)) { +var429 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce430!=NULL)) { +var431 = varonce430; } else { -var493 = " = "; -var494 = 3; -var495 = standard___standard__NativeString___to_s_with_length(var493, var494); -var492 = var495; -varonce491 = var492; +var432 = " = "; +var433 = standard___standard__NativeString___to_s_with_length(var432, 3l); +var431 = var433; +varonce430 = var431; } -if (varonce496) { -var497 = varonce496; +((struct instance_standard__NativeArray*)var429)->values[1]=var431; +if (likely(varonce434!=NULL)) { +var435 = varonce434; } else { -var498 = ".class->color;"; -var499 = 14; -var500 = standard___standard__NativeString___to_s_with_length(var498, var499); -var497 = var500; -varonce496 = var497; -} -var501 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var501 = array_instance Array[Object] */ -var502 = 4; -var503 = NEW_standard__NativeArray(var502, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var503)->values[0] = (val*) var_cltype; -((struct instance_standard__NativeArray*)var503)->values[1] = (val*) var492; -((struct instance_standard__NativeArray*)var503)->values[2] = (val*) var_entry; -((struct instance_standard__NativeArray*)var503)->values[3] = (val*) var497; -{ -((void (*)(val* self, val* p0, long p1))(var501->class->vft[COLOR_standard__array__Array__with_native]))(var501, var503, var502) /* with_native on */; +var436 = ".class->color;"; +var437 = standard___standard__NativeString___to_s_with_length(var436, 14l); +var435 = var437; +varonce434 = var435; } +((struct instance_standard__NativeArray*)var429)->values[3]=var435; +} else { +var429 = varonce428; +varonce428 = NULL; } +((struct instance_standard__NativeArray*)var429)->values[0]=var_cltype; +((struct instance_standard__NativeArray*)var429)->values[2]=var_entry; { -var504 = ((val* (*)(val* self))(var501->class->vft[COLOR_standard__string__Object__to_s]))(var501) /* to_s on */; +var438 = ((val*(*)(val* self))(var429->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var429); /* native_to_s on */ } +varonce428 = var429; { -nit___nit__AbstractCompilerVisitor___add(self, var504); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var438); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce505) { -var506 = varonce505; +if (unlikely(varonce439==NULL)) { +var440 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce441!=NULL)) { +var442 = varonce441; } else { -var507 = " = "; -var508 = 3; -var509 = standard___standard__NativeString___to_s_with_length(var507, var508); -var506 = var509; -varonce505 = var506; +var443 = " = "; +var444 = standard___standard__NativeString___to_s_with_length(var443, 3l); +var442 = var444; +varonce441 = var442; } -if (varonce510) { -var511 = varonce510; +((struct instance_standard__NativeArray*)var440)->values[1]=var442; +if (likely(varonce445!=NULL)) { +var446 = varonce445; } else { -var512 = ".class->id;"; -var513 = 11; -var514 = standard___standard__NativeString___to_s_with_length(var512, var513); -var511 = var514; -varonce510 = var511; -} -var515 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var515 = array_instance Array[Object] */ -var516 = 4; -var517 = NEW_standard__NativeArray(var516, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var517)->values[0] = (val*) var_idtype; -((struct instance_standard__NativeArray*)var517)->values[1] = (val*) var506; -((struct instance_standard__NativeArray*)var517)->values[2] = (val*) var_entry; -((struct instance_standard__NativeArray*)var517)->values[3] = (val*) var511; -{ -((void (*)(val* self, val* p0, long p1))(var515->class->vft[COLOR_standard__array__Array__with_native]))(var515, var517, var516) /* with_native on */; +var447 = ".class->id;"; +var448 = standard___standard__NativeString___to_s_with_length(var447, 11l); +var446 = var448; +varonce445 = var446; } +((struct instance_standard__NativeArray*)var440)->values[3]=var446; +} else { +var440 = varonce439; +varonce439 = NULL; } +((struct instance_standard__NativeArray*)var440)->values[0]=var_idtype; +((struct instance_standard__NativeArray*)var440)->values[2]=var_entry; { -var518 = ((val* (*)(val* self))(var515->class->vft[COLOR_standard__string__Object__to_s]))(var515) /* to_s on */; +var449 = ((val*(*)(val* self))(var440->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var440); /* native_to_s on */ } +varonce439 = var440; { -nit___nit__AbstractCompilerVisitor___add(self, var518); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var449); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -var_520 = var_maybe_null; +var_451 = var_maybe_null; if (var_maybe_null){ -if (varonce521) { -var522 = varonce521; +if (likely(varonce452!=NULL)) { +var453 = varonce452; } else { -var523 = "0"; -var524 = 1; -var525 = standard___standard__NativeString___to_s_with_length(var523, var524); -var522 = var525; -varonce521 = var522; +var454 = "0"; +var455 = standard___standard__NativeString___to_s_with_length(var454, 1l); +var453 = var455; +varonce452 = var453; } { -var526 = ((short int (*)(val* self, val* p0))(var_accept_null->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_accept_null, var522) /* == on */; +var456 = ((short int(*)(val* self, val* p0))(var_accept_null->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_accept_null, var453); /* == on */ } -var519 = var526; +var450 = var456; } else { -var519 = var_520; +var450 = var_451; } -if (var519){ -if (varonce527) { -var528 = varonce527; +if (var450){ +if (likely(varonce457!=NULL)) { +var458 = varonce457; } else { -var529 = "is_nullable"; -var530 = 11; -var531 = standard___standard__NativeString___to_s_with_length(var529, var530); -var528 = var531; -varonce527 = var528; +var459 = "is_nullable"; +var460 = standard___standard__NativeString___to_s_with_length(var459, 11l); +var458 = var460; +varonce457 = var458; } { -var532 = nit___nit__AbstractCompilerVisitor___get_name(self, var528); +var461 = nit___nit__AbstractCompilerVisitor___get_name(self, var458); } -var_is_nullable = var532; -if (varonce533) { -var534 = varonce533; +var_is_nullable = var461; +if (unlikely(varonce462==NULL)) { +var463 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce464!=NULL)) { +var465 = varonce464; } else { -var535 = "short int "; -var536 = 10; -var537 = standard___standard__NativeString___to_s_with_length(var535, var536); -var534 = var537; -varonce533 = var534; +var466 = "short int "; +var467 = standard___standard__NativeString___to_s_with_length(var466, 10l); +var465 = var467; +varonce464 = var465; } -if (varonce538) { -var539 = varonce538; +((struct instance_standard__NativeArray*)var463)->values[0]=var465; +if (likely(varonce468!=NULL)) { +var469 = varonce468; } else { -var540 = ";"; -var541 = 1; -var542 = standard___standard__NativeString___to_s_with_length(var540, var541); -var539 = var542; -varonce538 = var539; -} -var543 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var543 = array_instance Array[Object] */ -var544 = 3; -var545 = NEW_standard__NativeArray(var544, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var545)->values[0] = (val*) var534; -((struct instance_standard__NativeArray*)var545)->values[1] = (val*) var_is_nullable; -((struct instance_standard__NativeArray*)var545)->values[2] = (val*) var539; -{ -((void (*)(val* self, val* p0, long p1))(var543->class->vft[COLOR_standard__array__Array__with_native]))(var543, var545, var544) /* with_native on */; +var470 = ";"; +var471 = standard___standard__NativeString___to_s_with_length(var470, 1l); +var469 = var471; +varonce468 = var469; } +((struct instance_standard__NativeArray*)var463)->values[2]=var469; +} else { +var463 = varonce462; +varonce462 = NULL; } +((struct instance_standard__NativeArray*)var463)->values[1]=var_is_nullable; { -var546 = ((val* (*)(val* self))(var543->class->vft[COLOR_standard__string__Object__to_s]))(var543) /* to_s on */; +var472 = ((val*(*)(val* self))(var463->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var463); /* native_to_s on */ } +varonce462 = var463; { -nit___nit__AbstractCompilerVisitor___add_decl(self, var546); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +nit___nit__AbstractCompilerVisitor___add_decl(self, var472); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } -if (varonce547) { -var548 = varonce547; +if (unlikely(varonce473==NULL)) { +var474 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce475!=NULL)) { +var476 = varonce475; } else { -var549 = " = "; -var550 = 3; -var551 = standard___standard__NativeString___to_s_with_length(var549, var550); -var548 = var551; -varonce547 = var548; +var477 = " = "; +var478 = standard___standard__NativeString___to_s_with_length(var477, 3l); +var476 = var478; +varonce475 = var476; } -if (varonce552) { -var553 = varonce552; +((struct instance_standard__NativeArray*)var474)->values[1]=var476; +if (likely(varonce479!=NULL)) { +var480 = varonce479; } else { -var554 = ".is_nullable;"; -var555 = 13; -var556 = standard___standard__NativeString___to_s_with_length(var554, var555); -var553 = var556; -varonce552 = var553; -} -var557 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var557 = array_instance Array[Object] */ -var558 = 4; -var559 = NEW_standard__NativeArray(var558, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var559)->values[0] = (val*) var_is_nullable; -((struct instance_standard__NativeArray*)var559)->values[1] = (val*) var548; -((struct instance_standard__NativeArray*)var559)->values[2] = (val*) var_entry; -((struct instance_standard__NativeArray*)var559)->values[3] = (val*) var553; -{ -((void (*)(val* self, val* p0, long p1))(var557->class->vft[COLOR_standard__array__Array__with_native]))(var557, var559, var558) /* with_native on */; +var481 = ".is_nullable;"; +var482 = standard___standard__NativeString___to_s_with_length(var481, 13l); +var480 = var482; +varonce479 = var480; } +((struct instance_standard__NativeArray*)var474)->values[3]=var480; +} else { +var474 = varonce473; +varonce473 = NULL; } +((struct instance_standard__NativeArray*)var474)->values[0]=var_is_nullable; +((struct instance_standard__NativeArray*)var474)->values[2]=var_entry; { -var560 = ((val* (*)(val* self))(var557->class->vft[COLOR_standard__string__Object__to_s]))(var557) /* to_s on */; +var483 = ((val*(*)(val* self))(var474->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var474); /* native_to_s on */ } +varonce473 = var474; { -nit___nit__AbstractCompilerVisitor___add(self, var560); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var483); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } { -var561 = standard___standard__String___Object__to_s(var_is_nullable); +var484 = standard___standard__String___Object__to_s(var_is_nullable); } -var_accept_null = var561; +var_accept_null = var484; } else { } { { /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on */ -var564 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ -if (unlikely(var564 == NULL)) { +var487 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ +if (unlikely(var487 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1059); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1102); +fatal_exit(1); } -var562 = var564; -RET_LABEL563:(void)0; +var485 = var487; +RET_LABEL486:(void)0; } } { -{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (var562) on */ -var567 = var562->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ -if (unlikely(var567 == NULL)) { +{ /* Inline abstract_compiler#AbstractCompiler#modelbuilder (var485) on */ +var490 = var485->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___modelbuilder].val; /* _modelbuilder on */ +if (unlikely(var490 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 481); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 522); +fatal_exit(1); } -var565 = var567; -RET_LABEL566:(void)0; +var488 = var490; +RET_LABEL489:(void)0; } } { -{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var565) on */ -var570 = var565->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ -if (unlikely(var570 == NULL)) { +{ /* Inline modelbuilder_base#ModelBuilder#toolcontext (var488) on */ +var493 = var488->attrs[COLOR_nit__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on */ +if (unlikely(var493 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext"); PRINT_ERROR(" (%s:%d)\n", FILE_nit__modelbuilder_base, 47); -show_backtrace(1); +fatal_exit(1); } -var568 = var570; -RET_LABEL569:(void)0; +var491 = var493; +RET_LABEL492:(void)0; } } { -{ /* Inline abstract_compiler#ToolContext#opt_typing_test_metrics (var568) on */ -var573 = var568->attrs[COLOR_nit__abstract_compiler__ToolContext___opt_typing_test_metrics].val; /* _opt_typing_test_metrics on */ -if (unlikely(var573 == NULL)) { +{ /* Inline abstract_compiler#ToolContext#opt_typing_test_metrics (var491) on */ +var496 = var491->attrs[COLOR_nit__abstract_compiler__ToolContext___opt_typing_test_metrics].val; /* _opt_typing_test_metrics on */ +if (unlikely(var496 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_typing_test_metrics"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 59); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 60); +fatal_exit(1); } -var571 = var573; -RET_LABEL572:(void)0; +var494 = var496; +RET_LABEL495:(void)0; } } { -{ /* Inline opts#Option#value (var571) on */ -var576 = var571->attrs[COLOR_opts__Option___value].val; /* _value on */ -var574 = var576; -RET_LABEL575:(void)0; +{ /* Inline opts#Option#value (var494) on */ +var499 = var494->attrs[COLOR_opts__Option___value].val; /* _value on */ +var497 = var499; +RET_LABEL498:(void)0; } } -var577 = ((struct instance_standard__Bool*)var574)->value; /* autounbox from nullable Object to Bool */; -if (var577){ +var500 = (short int)((long)(var497)>>2); +if (var500){ { { /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on */ -var580 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ -if (unlikely(var580 == NULL)) { +var503 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ +if (unlikely(var503 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1059); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1102); +fatal_exit(1); } -var578 = var580; -RET_LABEL579:(void)0; +var501 = var503; +RET_LABEL502:(void)0; } } { -{ /* Inline abstract_compiler#AbstractCompiler#count_type_test_unresolved (var578) on */ -var583 = var578->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___count_type_test_unresolved].val; /* _count_type_test_unresolved on */ -if (unlikely(var583 == NULL)) { +{ /* Inline abstract_compiler#AbstractCompiler#count_type_test_unresolved (var501) on */ +var506 = var501->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___count_type_test_unresolved].val; /* _count_type_test_unresolved on */ +if (unlikely(var506 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _count_type_test_unresolved"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 965); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1016); +fatal_exit(1); } -var581 = var583; -RET_LABEL582:(void)0; +var504 = var506; +RET_LABEL505:(void)0; } } -var_584 = var581; -var_585 = var_tag; +var_507 = var504; +var_508 = var_tag; { -var586 = standard___standard__HashMap___standard__abstract_collection__MapRead___91d_93d(var_584, var_585); +var509 = standard___standard__HashMap___standard__abstract_collection__MapRead___91d_93d(var_507, var_508); } -var587 = 1; { -{ /* Inline kernel#Int#+ (var586,var587) on */ -/* Covariant cast for argument 0 (i) isa OTHER */ -/* isa OTHER */ -var590 = 1; /* easy isa OTHER*/ -if (unlikely(!var590)) { -var_class_name593 = type_standard__Int.name; -PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name593); -PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413); -show_backtrace(1); +{ /* Inline kernel#Int#+ (var509,1l) on */ +/* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */ +/* <1l:Int> isa OTHER */ +var512 = 1; /* easy <1l:Int> isa OTHER*/ +if (unlikely(!var512)) { +var_class_name515 = type_standard__Int.name; +PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name515); +PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 537); +fatal_exit(1); } -var594 = ((struct instance_standard__Int*)var586)->value; /* autounbox from nullable Object to Int */; -var595 = var594 + var587; -var588 = var595; -goto RET_LABEL589; -RET_LABEL589:(void)0; +var516 = (long)(var509)>>2; +var517 = var516 + 1l; +var510 = var517; +goto RET_LABEL511; +RET_LABEL511:(void)0; } } { -var596 = BOX_standard__Int(var588); /* autobox from Int to nullable Object */ -standard___standard__HashMap___standard__abstract_collection__Map___91d_93d_61d(var_584, var_585, var596); /* Direct call hash_collection#HashMap#[]= on */ +var518 = (val*)(var510<<2|1); +standard___standard__HashMap___standard__abstract_collection__Map___91d_93d_61d(var_507, var_508, var518); /* Direct call hash_collection#HashMap#[]= on */ +} +if (unlikely(varonce519==NULL)) { +var520 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce521!=NULL)) { +var522 = varonce521; +} else { +var523 = "count_type_test_unresolved_"; +var524 = standard___standard__NativeString___to_s_with_length(var523, 27l); +var522 = var524; +varonce521 = var522; } -if (varonce597) { -var598 = varonce597; +((struct instance_standard__NativeArray*)var520)->values[0]=var522; +if (likely(varonce525!=NULL)) { +var526 = varonce525; } else { -var599 = "count_type_test_unresolved_"; -var600 = 27; -var601 = standard___standard__NativeString___to_s_with_length(var599, var600); -var598 = var601; -varonce597 = var598; +var527 = "++;"; +var528 = standard___standard__NativeString___to_s_with_length(var527, 3l); +var526 = var528; +varonce525 = var526; } -if (varonce602) { -var603 = varonce602; +((struct instance_standard__NativeArray*)var520)->values[2]=var526; } else { -var604 = "++;"; -var605 = 3; -var606 = standard___standard__NativeString___to_s_with_length(var604, var605); -var603 = var606; -varonce602 = var603; +var520 = varonce519; +varonce519 = NULL; } -var607 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var607 = array_instance Array[Object] */ -var608 = 3; -var609 = NEW_standard__NativeArray(var608, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var609)->values[0] = (val*) var598; -((struct instance_standard__NativeArray*)var609)->values[1] = (val*) var_tag; -((struct instance_standard__NativeArray*)var609)->values[2] = (val*) var603; +((struct instance_standard__NativeArray*)var520)->values[1]=var_tag; { -((void (*)(val* self, val* p0, long p1))(var607->class->vft[COLOR_standard__array__Array__with_native]))(var607, var609, var608) /* with_native on */; -} -} -{ -var610 = ((val* (*)(val* self))(var607->class->vft[COLOR_standard__string__Object__to_s]))(var607) /* to_s on */; +var529 = ((val*(*)(val* self))(var520->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var520); /* native_to_s on */ } +varonce519 = var520; { -nit___nit__AbstractCompilerVisitor___add(self, var610); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var529); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } } else { } } else { -if (varonce611) { -var612 = varonce611; +if (unlikely(varonce530==NULL)) { +var531 = NEW_standard__NativeArray(5l, &type_standard__NativeArray__standard__String); +if (likely(varonce532!=NULL)) { +var533 = varonce532; } else { -var613 = "type_test("; -var614 = 10; -var615 = standard___standard__NativeString___to_s_with_length(var613, var614); -var612 = var615; -varonce611 = var612; +var534 = "type_test("; +var535 = standard___standard__NativeString___to_s_with_length(var534, 10l); +var533 = var535; +varonce532 = var533; } -{ -var616 = nit___nit__RuntimeVariable___standard__string__Object__inspect(var_value); +((struct instance_standard__NativeArray*)var531)->values[0]=var533; +if (likely(varonce536!=NULL)) { +var537 = varonce536; +} else { +var538 = ", "; +var539 = standard___standard__NativeString___to_s_with_length(var538, 2l); +var537 = var539; +varonce536 = var537; } -if (varonce617) { -var618 = varonce617; +((struct instance_standard__NativeArray*)var531)->values[2]=var537; +if (likely(varonce540!=NULL)) { +var541 = varonce540; } else { -var619 = ", "; -var620 = 2; -var621 = standard___standard__NativeString___to_s_with_length(var619, var620); -var618 = var621; -varonce617 = var618; +var542 = ")"; +var543 = standard___standard__NativeString___to_s_with_length(var542, 1l); +var541 = var543; +varonce540 = var541; } -if (varonce622) { -var623 = varonce622; +((struct instance_standard__NativeArray*)var531)->values[4]=var541; } else { -var624 = ")"; -var625 = 1; -var626 = standard___standard__NativeString___to_s_with_length(var624, var625); -var623 = var626; -varonce622 = var623; +var531 = varonce530; +varonce530 = NULL; } -var627 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var627 = array_instance Array[Object] */ -var628 = 5; -var629 = NEW_standard__NativeArray(var628, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var629)->values[0] = (val*) var612; -((struct instance_standard__NativeArray*)var629)->values[1] = (val*) var616; -((struct instance_standard__NativeArray*)var629)->values[2] = (val*) var618; -((struct instance_standard__NativeArray*)var629)->values[3] = (val*) var_mtype; -((struct instance_standard__NativeArray*)var629)->values[4] = (val*) var623; { -((void (*)(val* self, val* p0, long p1))(var627->class->vft[COLOR_standard__array__Array__with_native]))(var627, var629, var628) /* with_native on */; +var544 = nit___nit__RuntimeVariable___standard__string__Object__inspect(var_value); } +((struct instance_standard__NativeArray*)var531)->values[1]=var544; +{ +var545 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_standard__string__Object__to_s]))(var_mtype); /* to_s on */ } +((struct instance_standard__NativeArray*)var531)->values[3]=var545; { -var630 = ((val* (*)(val* self))(var627->class->vft[COLOR_standard__string__Object__to_s]))(var627) /* to_s on */; +var546 = ((val*(*)(val* self))(var531->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var531); /* native_to_s on */ } +varonce530 = var531; { -nit___nit__AbstractCompilerVisitor___debug(self, var630); /* Direct call abstract_compiler#AbstractCompilerVisitor#debug on */ +nit___nit__AbstractCompilerVisitor___debug(self, var546); /* Direct call abstract_compiler#AbstractCompilerVisitor#debug on */ } PRINT_ERROR("Runtime error: %s", "Aborted"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 571); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 582); +fatal_exit(1); } } if (var_maybe_null){ -if (varonce631) { -var632 = varonce631; +if (unlikely(varonce547==NULL)) { +var548 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce549!=NULL)) { +var550 = varonce549; } else { -var633 = "if("; -var634 = 3; -var635 = standard___standard__NativeString___to_s_with_length(var633, var634); -var632 = var635; -varonce631 = var632; +var551 = "if("; +var552 = standard___standard__NativeString___to_s_with_length(var551, 3l); +var550 = var552; +varonce549 = var550; } -if (varonce636) { -var637 = varonce636; +((struct instance_standard__NativeArray*)var548)->values[0]=var550; +if (likely(varonce553!=NULL)) { +var554 = varonce553; } else { -var638 = " == NULL) {"; -var639 = 11; -var640 = standard___standard__NativeString___to_s_with_length(var638, var639); -var637 = var640; -varonce636 = var637; +var555 = " == NULL) {"; +var556 = standard___standard__NativeString___to_s_with_length(var555, 11l); +var554 = var556; +varonce553 = var554; } -var641 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var641 = array_instance Array[Object] */ -var642 = 3; -var643 = NEW_standard__NativeArray(var642, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var643)->values[0] = (val*) var632; -((struct instance_standard__NativeArray*)var643)->values[1] = (val*) var_value; -((struct instance_standard__NativeArray*)var643)->values[2] = (val*) var637; -{ -((void (*)(val* self, val* p0, long p1))(var641->class->vft[COLOR_standard__array__Array__with_native]))(var641, var643, var642) /* with_native on */; +((struct instance_standard__NativeArray*)var548)->values[2]=var554; +} else { +var548 = varonce547; +varonce547 = NULL; } +{ +var557 = ((val*(*)(val* self))(var_value->class->vft[COLOR_standard__string__Object__to_s]))(var_value); /* to_s on */ } +((struct instance_standard__NativeArray*)var548)->values[1]=var557; { -var644 = ((val* (*)(val* self))(var641->class->vft[COLOR_standard__string__Object__to_s]))(var641) /* to_s on */; +var558 = ((val*(*)(val* self))(var548->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var548); /* native_to_s on */ } +varonce547 = var548; { -nit___nit__AbstractCompilerVisitor___add(self, var644); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var558); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce645) { -var646 = varonce645; +if (unlikely(varonce559==NULL)) { +var560 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce561!=NULL)) { +var562 = varonce561; } else { -var647 = " = "; -var648 = 3; -var649 = standard___standard__NativeString___to_s_with_length(var647, var648); -var646 = var649; -varonce645 = var646; +var563 = " = "; +var564 = standard___standard__NativeString___to_s_with_length(var563, 3l); +var562 = var564; +varonce561 = var562; } -if (varonce650) { -var651 = varonce650; +((struct instance_standard__NativeArray*)var560)->values[1]=var562; +if (likely(varonce565!=NULL)) { +var566 = varonce565; } else { -var652 = ";"; -var653 = 1; -var654 = standard___standard__NativeString___to_s_with_length(var652, var653); -var651 = var654; -varonce650 = var651; +var567 = ";"; +var568 = standard___standard__NativeString___to_s_with_length(var567, 1l); +var566 = var568; +varonce565 = var566; } -var655 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var655 = array_instance Array[Object] */ -var656 = 4; -var657 = NEW_standard__NativeArray(var656, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var657)->values[0] = (val*) var_res; -((struct instance_standard__NativeArray*)var657)->values[1] = (val*) var646; -((struct instance_standard__NativeArray*)var657)->values[2] = (val*) var_accept_null; -((struct instance_standard__NativeArray*)var657)->values[3] = (val*) var651; -{ -((void (*)(val* self, val* p0, long p1))(var655->class->vft[COLOR_standard__array__Array__with_native]))(var655, var657, var656) /* with_native on */; +((struct instance_standard__NativeArray*)var560)->values[3]=var566; +} else { +var560 = varonce559; +varonce559 = NULL; } +{ +var569 = ((val*(*)(val* self))(var_res->class->vft[COLOR_standard__string__Object__to_s]))(var_res); /* to_s on */ } +((struct instance_standard__NativeArray*)var560)->values[0]=var569; +((struct instance_standard__NativeArray*)var560)->values[2]=var_accept_null; { -var658 = ((val* (*)(val* self))(var655->class->vft[COLOR_standard__string__Object__to_s]))(var655) /* to_s on */; +var570 = ((val*(*)(val* self))(var560->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var560); /* native_to_s on */ } +varonce559 = var560; { -nit___nit__AbstractCompilerVisitor___add(self, var658); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var570); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce659) { -var660 = varonce659; +if (likely(varonce571!=NULL)) { +var572 = varonce571; } else { -var661 = "} else {"; -var662 = 8; -var663 = standard___standard__NativeString___to_s_with_length(var661, var662); -var660 = var663; -varonce659 = var660; +var573 = "} else {"; +var574 = standard___standard__NativeString___to_s_with_length(var573, 8l); +var572 = var574; +varonce571 = var572; } { -nit___nit__AbstractCompilerVisitor___add(self, var660); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var572); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } } else { } -if (varonce664) { -var665 = varonce664; +if (unlikely(varonce575==NULL)) { +var576 = NEW_standard__NativeArray(5l, &type_standard__NativeArray__standard__String); +if (likely(varonce577!=NULL)) { +var578 = varonce577; } else { -var666 = "if("; -var667 = 3; -var668 = standard___standard__NativeString___to_s_with_length(var666, var667); -var665 = var668; -varonce664 = var665; +var579 = "if("; +var580 = standard___standard__NativeString___to_s_with_length(var579, 3l); +var578 = var580; +varonce577 = var578; } -if (varonce669) { -var670 = varonce669; +((struct instance_standard__NativeArray*)var576)->values[0]=var578; +if (likely(varonce581!=NULL)) { +var582 = varonce581; } else { -var671 = " >= "; -var672 = 4; -var673 = standard___standard__NativeString___to_s_with_length(var671, var672); -var670 = var673; -varonce669 = var670; +var583 = " >= "; +var584 = standard___standard__NativeString___to_s_with_length(var583, 4l); +var582 = var584; +varonce581 = var582; } -if (varonce674) { -var675 = varonce674; +((struct instance_standard__NativeArray*)var576)->values[2]=var582; +if (likely(varonce585!=NULL)) { +var586 = varonce585; } else { -var676 = "type_table->size) {"; -var677 = 19; -var678 = standard___standard__NativeString___to_s_with_length(var676, var677); -var675 = var678; -varonce674 = var675; -} -var679 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var679 = array_instance Array[Object] */ -var680 = 5; -var681 = NEW_standard__NativeArray(var680, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var681)->values[0] = (val*) var665; -((struct instance_standard__NativeArray*)var681)->values[1] = (val*) var_cltype; -((struct instance_standard__NativeArray*)var681)->values[2] = (val*) var670; -((struct instance_standard__NativeArray*)var681)->values[3] = (val*) var_class_ptr; -((struct instance_standard__NativeArray*)var681)->values[4] = (val*) var675; -{ -((void (*)(val* self, val* p0, long p1))(var679->class->vft[COLOR_standard__array__Array__with_native]))(var679, var681, var680) /* with_native on */; +var587 = "type_table->size) {"; +var588 = standard___standard__NativeString___to_s_with_length(var587, 19l); +var586 = var588; +varonce585 = var586; } +((struct instance_standard__NativeArray*)var576)->values[4]=var586; +} else { +var576 = varonce575; +varonce575 = NULL; } +((struct instance_standard__NativeArray*)var576)->values[1]=var_cltype; +((struct instance_standard__NativeArray*)var576)->values[3]=var_class_ptr; { -var682 = ((val* (*)(val* self))(var679->class->vft[COLOR_standard__string__Object__to_s]))(var679) /* to_s on */; +var589 = ((val*(*)(val* self))(var576->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var576); /* native_to_s on */ } +varonce575 = var576; { -nit___nit__AbstractCompilerVisitor___add(self, var682); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var589); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce683) { -var684 = varonce683; +if (unlikely(varonce590==NULL)) { +var591 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce592!=NULL)) { +var593 = varonce592; } else { -var685 = " = 0;"; -var686 = 5; -var687 = standard___standard__NativeString___to_s_with_length(var685, var686); -var684 = var687; -varonce683 = var684; +var594 = " = 0;"; +var595 = standard___standard__NativeString___to_s_with_length(var594, 5l); +var593 = var595; +varonce592 = var593; } -var688 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var688 = array_instance Array[Object] */ -var689 = 2; -var690 = NEW_standard__NativeArray(var689, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var690)->values[0] = (val*) var_res; -((struct instance_standard__NativeArray*)var690)->values[1] = (val*) var684; -{ -((void (*)(val* self, val* p0, long p1))(var688->class->vft[COLOR_standard__array__Array__with_native]))(var688, var690, var689) /* with_native on */; +((struct instance_standard__NativeArray*)var591)->values[1]=var593; +} else { +var591 = varonce590; +varonce590 = NULL; } +{ +var596 = ((val*(*)(val* self))(var_res->class->vft[COLOR_standard__string__Object__to_s]))(var_res); /* to_s on */ } +((struct instance_standard__NativeArray*)var591)->values[0]=var596; { -var691 = ((val* (*)(val* self))(var688->class->vft[COLOR_standard__string__Object__to_s]))(var688) /* to_s on */; +var597 = ((val*(*)(val* self))(var591->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var591); /* native_to_s on */ } +varonce590 = var591; { -nit___nit__AbstractCompilerVisitor___add(self, var691); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var597); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce692) { -var693 = varonce692; +if (likely(varonce598!=NULL)) { +var599 = varonce598; } else { -var694 = "} else {"; -var695 = 8; -var696 = standard___standard__NativeString___to_s_with_length(var694, var695); -var693 = var696; -varonce692 = var693; +var600 = "} else {"; +var601 = standard___standard__NativeString___to_s_with_length(var600, 8l); +var599 = var601; +varonce598 = var599; } { -nit___nit__AbstractCompilerVisitor___add(self, var693); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var599); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce697) { -var698 = varonce697; +if (unlikely(varonce602==NULL)) { +var603 = NEW_standard__NativeArray(8l, &type_standard__NativeArray__standard__String); +if (likely(varonce604!=NULL)) { +var605 = varonce604; } else { -var699 = " = "; -var700 = 3; -var701 = standard___standard__NativeString___to_s_with_length(var699, var700); -var698 = var701; -varonce697 = var698; +var606 = " = "; +var607 = standard___standard__NativeString___to_s_with_length(var606, 3l); +var605 = var607; +varonce604 = var605; } -if (varonce702) { -var703 = varonce702; +((struct instance_standard__NativeArray*)var603)->values[1]=var605; +if (likely(varonce608!=NULL)) { +var609 = varonce608; } else { -var704 = "type_table->table["; -var705 = 18; -var706 = standard___standard__NativeString___to_s_with_length(var704, var705); -var703 = var706; -varonce702 = var703; +var610 = "type_table->table["; +var611 = standard___standard__NativeString___to_s_with_length(var610, 18l); +var609 = var611; +varonce608 = var609; } -if (varonce707) { -var708 = varonce707; +((struct instance_standard__NativeArray*)var603)->values[3]=var609; +if (likely(varonce612!=NULL)) { +var613 = varonce612; } else { -var709 = "] == "; -var710 = 5; -var711 = standard___standard__NativeString___to_s_with_length(var709, var710); -var708 = var711; -varonce707 = var708; +var614 = "] == "; +var615 = standard___standard__NativeString___to_s_with_length(var614, 5l); +var613 = var615; +varonce612 = var613; } -if (varonce712) { -var713 = varonce712; +((struct instance_standard__NativeArray*)var603)->values[5]=var613; +if (likely(varonce616!=NULL)) { +var617 = varonce616; } else { -var714 = ";"; -var715 = 1; -var716 = standard___standard__NativeString___to_s_with_length(var714, var715); -var713 = var716; -varonce712 = var713; +var618 = ";"; +var619 = standard___standard__NativeString___to_s_with_length(var618, 1l); +var617 = var619; +varonce616 = var617; } -var717 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var717 = array_instance Array[Object] */ -var718 = 8; -var719 = NEW_standard__NativeArray(var718, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var719)->values[0] = (val*) var_res; -((struct instance_standard__NativeArray*)var719)->values[1] = (val*) var698; -((struct instance_standard__NativeArray*)var719)->values[2] = (val*) var_class_ptr; -((struct instance_standard__NativeArray*)var719)->values[3] = (val*) var703; -((struct instance_standard__NativeArray*)var719)->values[4] = (val*) var_cltype; -((struct instance_standard__NativeArray*)var719)->values[5] = (val*) var708; -((struct instance_standard__NativeArray*)var719)->values[6] = (val*) var_idtype; -((struct instance_standard__NativeArray*)var719)->values[7] = (val*) var713; -{ -((void (*)(val* self, val* p0, long p1))(var717->class->vft[COLOR_standard__array__Array__with_native]))(var717, var719, var718) /* with_native on */; +((struct instance_standard__NativeArray*)var603)->values[7]=var617; +} else { +var603 = varonce602; +varonce602 = NULL; } +{ +var620 = ((val*(*)(val* self))(var_res->class->vft[COLOR_standard__string__Object__to_s]))(var_res); /* to_s on */ } +((struct instance_standard__NativeArray*)var603)->values[0]=var620; +((struct instance_standard__NativeArray*)var603)->values[2]=var_class_ptr; +((struct instance_standard__NativeArray*)var603)->values[4]=var_cltype; +((struct instance_standard__NativeArray*)var603)->values[6]=var_idtype; { -var720 = ((val* (*)(val* self))(var717->class->vft[COLOR_standard__string__Object__to_s]))(var717) /* to_s on */; +var621 = ((val*(*)(val* self))(var603->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var603); /* native_to_s on */ } +varonce602 = var603; { -nit___nit__AbstractCompilerVisitor___add(self, var720); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var621); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce721) { -var722 = varonce721; +if (likely(varonce622!=NULL)) { +var623 = varonce622; } else { -var723 = "}"; -var724 = 1; -var725 = standard___standard__NativeString___to_s_with_length(var723, var724); -var722 = var725; -varonce721 = var722; +var624 = "}"; +var625 = standard___standard__NativeString___to_s_with_length(var624, 1l); +var623 = var625; +varonce622 = var623; } { -nit___nit__AbstractCompilerVisitor___add(self, var722); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var623); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } if (var_maybe_null){ -if (varonce726) { -var727 = varonce726; +if (likely(varonce626!=NULL)) { +var627 = varonce626; } else { -var728 = "}"; -var729 = 1; -var730 = standard___standard__NativeString___to_s_with_length(var728, var729); -var727 = var730; -varonce726 = var727; +var628 = "}"; +var629 = standard___standard__NativeString___to_s_with_length(var628, 1l); +var627 = var629; +varonce626 = var627; } { -nit___nit__AbstractCompilerVisitor___add(self, var727); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var627); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } } else { } @@ -2855,20 +2661,20 @@ val* var4 /* : MClass */; val* var6 /* : MClass */; val* var7 /* : MClassKind */; val* var9 /* : MClassKind */; -val* var10 /* : MClassKind */; -short int var11 /* : Bool */; +val* var10 /* : Sys */; +val* var11 /* : MClassKind */; +short int var12 /* : Bool */; val* var_other /* var other: nullable Object */; -short int var13 /* : Bool */; -short int var15 /* : Bool */; -short int var_16 /* var : Bool */; -val* var17 /* : MClass */; -val* var19 /* : MClass */; -val* var20 /* : String */; -val* var22 /* : String */; -static val* varonce; +short int var14 /* : Bool */; +short int var16 /* : Bool */; +short int var_17 /* var : Bool */; +val* var18 /* : MClass */; +val* var20 /* : MClass */; +val* var21 /* : String */; val* var23 /* : String */; -char* var24 /* : NativeString */; -long var25 /* : Int */; +static val* varonce; +val* var24 /* : String */; +char* var25 /* : NativeString */; val* var26 /* : FlatString */; short int var27 /* : Bool */; val* var_other29 /* var other: nullable Object */; @@ -2882,33 +2688,31 @@ val* var38 /* : MClassType */; val* var_pointer_type /* var pointer_type: MClassType */; val* var39 /* : RuntimeVariable */; val* var_res /* var res: RuntimeVariable */; +val* var41 /* : NativeArray[String] */; static val* varonce40; -val* var41 /* : String */; -char* var42 /* : NativeString */; -long var43 /* : Int */; -val* var44 /* : FlatString */; -val* var45 /* : String */; +static val* varonce42; +val* var43 /* : String */; +char* var44 /* : NativeString */; +val* var45 /* : FlatString */; static val* varonce46; val* var47 /* : String */; char* var48 /* : NativeString */; -long var49 /* : Int */; -val* var50 /* : FlatString */; -static val* varonce51; -val* var52 /* : String */; -char* var53 /* : NativeString */; -long var54 /* : Int */; -val* var55 /* : FlatString */; -val* var56 /* : MType */; -val* var58 /* : MType */; -static val* varonce59; +val* var49 /* : FlatString */; +static val* varonce50; +val* var51 /* : String */; +char* var52 /* : NativeString */; +val* var53 /* : FlatString */; +static val* varonce54; +val* var55 /* : String */; +char* var56 /* : NativeString */; +val* var57 /* : FlatString */; +val* var58 /* : String */; +val* var59 /* : String */; val* var60 /* : String */; -char* var61 /* : NativeString */; -long var62 /* : Int */; -val* var63 /* : FlatString */; -val* var64 /* : Array[Object] */; -long var65 /* : Int */; -val* var66 /* : NativeArray[Object] */; -val* var67 /* : String */; +val* var61 /* : MType */; +val* var63 /* : MType */; +val* var64 /* : String */; +val* var65 /* : String */; var_value = p0; var_mtype = p1; /* isa MClassType */ @@ -2926,8 +2730,8 @@ if (var3){ var6 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ if (unlikely(var6 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1058); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138); +fatal_exit(1); } var4 = var6; RET_LABEL5:(void)0; @@ -2938,76 +2742,76 @@ RET_LABEL5:(void)0; var9 = var4->attrs[COLOR_nit__model__MClass___kind].val; /* _kind on */ if (unlikely(var9 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _kind"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 399); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 436); +fatal_exit(1); } var7 = var9; RET_LABEL8:(void)0; } } +var10 = glob_sys; { -var10 = nit__model___standard__Object___extern_kind(self); +var11 = nit__model___standard__Sys___extern_kind(var10); } { -{ /* Inline kernel#Object#== (var7,var10) on */ -var_other = var10; +{ /* Inline kernel#Object#== (var7,var11) on */ +var_other = var11; { { /* Inline kernel#Object#is_same_instance (var7,var_other) on */ -var15 = var7 == var_other; -var13 = var15; -goto RET_LABEL14; -RET_LABEL14:(void)0; +var16 = var7 == var_other; +var14 = var16; +goto RET_LABEL15; +RET_LABEL15:(void)0; } } -var11 = var13; -goto RET_LABEL12; -RET_LABEL12:(void)0; +var12 = var14; +goto RET_LABEL13; +RET_LABEL13:(void)0; } } -var2 = var11; +var2 = var12; } else { var2 = var_; } -var_16 = var2; +var_17 = var2; if (var2){ { { /* Inline model#MClassType#mclass (var_mtype) on */ -var19 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var19 == NULL)) { +var20 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var20 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1058); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138); +fatal_exit(1); } -var17 = var19; -RET_LABEL18:(void)0; +var18 = var20; +RET_LABEL19:(void)0; } } { -{ /* Inline model#MClass#name (var17) on */ -var22 = var17->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ -if (unlikely(var22 == NULL)) { +{ /* Inline model#MClass#name (var18) on */ +var23 = var18->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ +if (unlikely(var23 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 348); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 362); +fatal_exit(1); } -var20 = var22; -RET_LABEL21:(void)0; +var21 = var23; +RET_LABEL22:(void)0; } } -if (varonce) { -var23 = varonce; +if (likely(varonce!=NULL)) { +var24 = varonce; } else { -var24 = "NativeString"; -var25 = 12; -var26 = standard___standard__NativeString___to_s_with_length(var24, var25); -var23 = var26; -varonce = var23; +var25 = "NativeString"; +var26 = standard___standard__NativeString___to_s_with_length(var25, 12l); +var24 = var26; +varonce = var24; } { -{ /* Inline kernel#Object#!= (var20,var23) on */ -var_other29 = var23; +{ /* Inline kernel#Object#!= (var21,var24) on */ +var_other29 = var24; { -var30 = ((short int (*)(val* self, val* p0))(var20->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var20, var_other29) /* == on */; +var30 = ((short int(*)(val* self, val* p0))(var21->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var21, var_other29); /* == on */ } var31 = !var30; var27 = var31; @@ -3017,7 +2821,7 @@ RET_LABEL28:(void)0; } var1 = var27; } else { -var1 = var_16; +var1 = var_17; } if (var1){ { @@ -3025,8 +2829,8 @@ if (var1){ var34 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ if (unlikely(var34 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1059); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1102); +fatal_exit(1); } var32 = var34; RET_LABEL33:(void)0; @@ -3037,8 +2841,8 @@ RET_LABEL33:(void)0; var37 = var32->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ if (unlikely(var37 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 515); +fatal_exit(1); } var35 = var37; RET_LABEL36:(void)0; @@ -3052,78 +2856,82 @@ var_pointer_type = var38; var39 = nit___nit__AbstractCompilerVisitor___new_var_extern(self, var_mtype); } var_res = var39; -if (varonce40) { -var41 = varonce40; +if (unlikely(varonce40==NULL)) { +var41 = NEW_standard__NativeArray(8l, &type_standard__NativeArray__standard__String); +if (likely(varonce42!=NULL)) { +var43 = varonce42; } else { -var42 = " = ((struct instance_"; -var43 = 21; -var44 = standard___standard__NativeString___to_s_with_length(var42, var43); -var41 = var44; -varonce40 = var41; -} -{ -var45 = ((val* (*)(val* self))(var_pointer_type->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_pointer_type) /* c_name on */; +var44 = " = ((struct instance_"; +var45 = standard___standard__NativeString___to_s_with_length(var44, 21l); +var43 = var45; +varonce42 = var43; } -if (varonce46) { +((struct instance_standard__NativeArray*)var41)->values[1]=var43; +if (likely(varonce46!=NULL)) { var47 = varonce46; } else { var48 = "*)"; -var49 = 2; -var50 = standard___standard__NativeString___to_s_with_length(var48, var49); -var47 = var50; +var49 = standard___standard__NativeString___to_s_with_length(var48, 2l); +var47 = var49; varonce46 = var47; } -if (varonce51) { -var52 = varonce51; +((struct instance_standard__NativeArray*)var41)->values[3]=var47; +if (likely(varonce50!=NULL)) { +var51 = varonce50; } else { -var53 = ")->value; /* unboxing "; -var54 = 22; -var55 = standard___standard__NativeString___to_s_with_length(var53, var54); -var52 = var55; -varonce51 = var52; +var52 = ")->value; /* unboxing "; +var53 = standard___standard__NativeString___to_s_with_length(var52, 22l); +var51 = var53; +varonce50 = var51; +} +((struct instance_standard__NativeArray*)var41)->values[5]=var51; +if (likely(varonce54!=NULL)) { +var55 = varonce54; +} else { +var56 = " */"; +var57 = standard___standard__NativeString___to_s_with_length(var56, 3l); +var55 = var57; +varonce54 = var55; +} +((struct instance_standard__NativeArray*)var41)->values[7]=var55; +} else { +var41 = varonce40; +varonce40 = NULL; +} +{ +var58 = ((val*(*)(val* self))(var_res->class->vft[COLOR_standard__string__Object__to_s]))(var_res); /* to_s on */ +} +((struct instance_standard__NativeArray*)var41)->values[0]=var58; +{ +var59 = ((val*(*)(val* self))(var_pointer_type->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_pointer_type); /* c_name on */ } +((struct instance_standard__NativeArray*)var41)->values[2]=var59; +{ +var60 = ((val*(*)(val* self))(var_value->class->vft[COLOR_standard__string__Object__to_s]))(var_value); /* to_s on */ +} +((struct instance_standard__NativeArray*)var41)->values[4]=var60; { { /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var58 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var58 == NULL)) { +var63 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var63 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); -} -var56 = var58; -RET_LABEL57:(void)0; +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1784); +fatal_exit(1); } +var61 = var63; +RET_LABEL62:(void)0; } -if (varonce59) { -var60 = varonce59; -} else { -var61 = " */"; -var62 = 3; -var63 = standard___standard__NativeString___to_s_with_length(var61, var62); -var60 = var63; -varonce59 = var60; } -var64 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var64 = array_instance Array[Object] */ -var65 = 8; -var66 = NEW_standard__NativeArray(var65, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var66)->values[0] = (val*) var_res; -((struct instance_standard__NativeArray*)var66)->values[1] = (val*) var41; -((struct instance_standard__NativeArray*)var66)->values[2] = (val*) var45; -((struct instance_standard__NativeArray*)var66)->values[3] = (val*) var47; -((struct instance_standard__NativeArray*)var66)->values[4] = (val*) var_value; -((struct instance_standard__NativeArray*)var66)->values[5] = (val*) var52; -((struct instance_standard__NativeArray*)var66)->values[6] = (val*) var56; -((struct instance_standard__NativeArray*)var66)->values[7] = (val*) var60; { -((void (*)(val* self, val* p0, long p1))(var64->class->vft[COLOR_standard__array__Array__with_native]))(var64, var66, var65) /* with_native on */; -} +var64 = ((val*(*)(val* self))(var61->class->vft[COLOR_standard__string__Object__to_s]))(var61); /* to_s on */ } +((struct instance_standard__NativeArray*)var41)->values[6]=var64; { -var67 = ((val* (*)(val* self))(var64->class->vft[COLOR_standard__string__Object__to_s]))(var64) /* to_s on */; +var65 = ((val*(*)(val* self))(var41->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var41); /* native_to_s on */ } +varonce40 = var41; { -nit___nit__AbstractCompilerVisitor___add(self, var67); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var65); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } var = var_res; goto RET_LABEL; @@ -3149,20 +2957,20 @@ val* var4 /* : MClass */; val* var6 /* : MClass */; val* var7 /* : MClassKind */; val* var9 /* : MClassKind */; -val* var10 /* : MClassKind */; -short int var11 /* : Bool */; +val* var10 /* : Sys */; +val* var11 /* : MClassKind */; +short int var12 /* : Bool */; val* var_other /* var other: nullable Object */; -short int var13 /* : Bool */; -short int var15 /* : Bool */; -short int var_16 /* var : Bool */; -val* var17 /* : MClass */; -val* var19 /* : MClass */; -val* var20 /* : String */; -val* var22 /* : String */; -static val* varonce; +short int var14 /* : Bool */; +short int var16 /* : Bool */; +short int var_17 /* var : Bool */; +val* var18 /* : MClass */; +val* var20 /* : MClass */; +val* var21 /* : String */; val* var23 /* : String */; -char* var24 /* : NativeString */; -long var25 /* : Int */; +static val* varonce; +val* var24 /* : String */; +char* var25 /* : NativeString */; val* var26 /* : FlatString */; short int var27 /* : Bool */; val* var_other29 /* var other: nullable Object */; @@ -3181,116 +2989,104 @@ val* var41 /* : AbstractCompiler */; val* var43 /* : AbstractCompiler */; val* var44 /* : nullable RapidTypeAnalysis */; val* var46 /* : nullable RapidTypeAnalysis */; -val* var47 /* : null */; +short int var47 /* : Bool */; short int var48 /* : Bool */; -short int var49 /* : Bool */; +short int var50 /* : Bool */; short int var51 /* : Bool */; -short int var52 /* : Bool */; -short int var_53 /* var : Bool */; -val* var54 /* : AbstractCompiler */; -val* var56 /* : AbstractCompiler */; -val* var57 /* : nullable RapidTypeAnalysis */; -val* var59 /* : nullable RapidTypeAnalysis */; -val* var60 /* : HashSet[MClassType] */; -val* var62 /* : HashSet[MClassType] */; -val* var63 /* : MType */; -val* var65 /* : MType */; -short int var66 /* : Bool */; -int cltype67; -int idtype68; +short int var_52 /* var : Bool */; +val* var53 /* : AbstractCompiler */; +val* var55 /* : AbstractCompiler */; +val* var56 /* : nullable RapidTypeAnalysis */; +val* var58 /* : nullable RapidTypeAnalysis */; +val* var59 /* : HashSet[MClassType] */; +val* var61 /* : HashSet[MClassType] */; +val* var62 /* : MType */; +val* var64 /* : MType */; +short int var65 /* : Bool */; +int cltype66; +int idtype67; const char* var_class_name; +short int var68 /* : Bool */; short int var69 /* : Bool */; -short int var70 /* : Bool */; -static val* varonce71; -val* var72 /* : String */; -char* var73 /* : NativeString */; -long var74 /* : Int */; +val* var71 /* : NativeArray[String] */; +static val* varonce70; +static val* varonce72; +val* var73 /* : String */; +char* var74 /* : NativeString */; val* var75 /* : FlatString */; -val* var76 /* : MType */; -val* var78 /* : MType */; -static val* varonce79; -val* var80 /* : String */; -char* var81 /* : NativeString */; -long var82 /* : Int */; +static val* varonce76; +val* var77 /* : String */; +char* var78 /* : NativeString */; +val* var79 /* : FlatString */; +static val* varonce80; +val* var81 /* : String */; +char* var82 /* : NativeString */; val* var83 /* : FlatString */; val* var84 /* : MType */; val* var86 /* : MType */; -static val* varonce87; -val* var88 /* : String */; -char* var89 /* : NativeString */; -long var90 /* : Int */; -val* var91 /* : FlatString */; -val* var92 /* : Array[Object] */; -long var93 /* : Int */; -val* var94 /* : NativeArray[Object] */; -val* var95 /* : String */; -static val* varonce96; -val* var97 /* : String */; -char* var98 /* : NativeString */; -long var99 /* : Int */; -val* var100 /* : FlatString */; -static val* varonce101; -val* var102 /* : String */; -char* var103 /* : NativeString */; -long var104 /* : Int */; -val* var105 /* : FlatString */; -val* var106 /* : String */; -val* var107 /* : Array[Object] */; -long var108 /* : Int */; -val* var109 /* : NativeArray[Object] */; -val* var110 /* : String */; +val* var87 /* : String */; +val* var88 /* : MType */; +val* var90 /* : MType */; +val* var91 /* : String */; +val* var92 /* : String */; +static val* varonce93; +val* var94 /* : String */; +char* var95 /* : NativeString */; +val* var96 /* : FlatString */; +val* var98 /* : NativeArray[String] */; +static val* varonce97; +static val* varonce99; +val* var100 /* : String */; +char* var101 /* : NativeString */; +val* var102 /* : FlatString */; +val* var103 /* : String */; +val* var104 /* : String */; +val* var106 /* : NativeArray[String] */; +static val* varonce105; +static val* varonce107; +val* var108 /* : String */; +char* var109 /* : NativeString */; +val* var110 /* : FlatString */; static val* varonce111; val* var112 /* : String */; char* var113 /* : NativeString */; -long var114 /* : Int */; -val* var115 /* : FlatString */; +val* var114 /* : FlatString */; +static val* varonce115; val* var116 /* : String */; -static val* varonce117; -val* var118 /* : String */; -char* var119 /* : NativeString */; -long var120 /* : Int */; -val* var121 /* : FlatString */; -static val* varonce122; +char* var117 /* : NativeString */; +val* var118 /* : FlatString */; +static val* varonce119; +val* var120 /* : String */; +char* var121 /* : NativeString */; +val* var122 /* : FlatString */; val* var123 /* : String */; -char* var124 /* : NativeString */; -long var125 /* : Int */; -val* var126 /* : FlatString */; -val* var127 /* : MType */; -val* var129 /* : MType */; -static val* varonce130; -val* var131 /* : String */; -char* var132 /* : NativeString */; -long var133 /* : Int */; -val* var134 /* : FlatString */; -val* var135 /* : Array[Object] */; -long var136 /* : Int */; -val* var137 /* : NativeArray[Object] */; +val* var124 /* : String */; +val* var125 /* : String */; +val* var126 /* : MType */; +val* var128 /* : MType */; +val* var129 /* : String */; +val* var130 /* : String */; +val* var132 /* : NativeArray[String] */; +static val* varonce131; +static val* varonce133; +val* var134 /* : String */; +char* var135 /* : NativeString */; +val* var136 /* : FlatString */; +val* var137 /* : String */; val* var138 /* : String */; +val* var140 /* : NativeArray[String] */; static val* varonce139; -val* var140 /* : String */; -char* var141 /* : NativeString */; -long var142 /* : Int */; -val* var143 /* : FlatString */; -val* var144 /* : String */; -val* var145 /* : Array[Object] */; -long var146 /* : Int */; -val* var147 /* : NativeArray[Object] */; -val* var148 /* : String */; -static val* varonce149; +static val* varonce141; +val* var142 /* : String */; +char* var143 /* : NativeString */; +val* var144 /* : FlatString */; +static val* varonce145; +val* var146 /* : String */; +char* var147 /* : NativeString */; +val* var148 /* : FlatString */; +val* var149 /* : String */; val* var150 /* : String */; -char* var151 /* : NativeString */; -long var152 /* : Int */; -val* var153 /* : FlatString */; -val* var154 /* : String */; -static val* varonce155; -val* var156 /* : String */; -char* var157 /* : NativeString */; -long var158 /* : Int */; -val* var159 /* : FlatString */; -val* var160 /* : Array[Object] */; -long var161 /* : Int */; -val* var162 /* : NativeArray[Object] */; -val* var163 /* : String */; +val* var151 /* : String */; var_value = p0; var_mtype = p1; /* isa MClassType */ @@ -3308,8 +3104,8 @@ if (var3){ var6 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ if (unlikely(var6 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1058); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138); +fatal_exit(1); } var4 = var6; RET_LABEL5:(void)0; @@ -3320,76 +3116,76 @@ RET_LABEL5:(void)0; var9 = var4->attrs[COLOR_nit__model__MClass___kind].val; /* _kind on */ if (unlikely(var9 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _kind"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 399); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 436); +fatal_exit(1); } var7 = var9; RET_LABEL8:(void)0; } } +var10 = glob_sys; { -var10 = nit__model___standard__Object___extern_kind(self); +var11 = nit__model___standard__Sys___extern_kind(var10); } { -{ /* Inline kernel#Object#== (var7,var10) on */ -var_other = var10; +{ /* Inline kernel#Object#== (var7,var11) on */ +var_other = var11; { { /* Inline kernel#Object#is_same_instance (var7,var_other) on */ -var15 = var7 == var_other; -var13 = var15; -goto RET_LABEL14; -RET_LABEL14:(void)0; +var16 = var7 == var_other; +var14 = var16; +goto RET_LABEL15; +RET_LABEL15:(void)0; } } -var11 = var13; -goto RET_LABEL12; -RET_LABEL12:(void)0; +var12 = var14; +goto RET_LABEL13; +RET_LABEL13:(void)0; } } -var2 = var11; +var2 = var12; } else { var2 = var_; } -var_16 = var2; +var_17 = var2; if (var2){ { { /* Inline model#MClassType#mclass (var_mtype) on */ -var19 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var19 == NULL)) { +var20 = var_mtype->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var20 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1058); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138); +fatal_exit(1); } -var17 = var19; -RET_LABEL18:(void)0; +var18 = var20; +RET_LABEL19:(void)0; } } { -{ /* Inline model#MClass#name (var17) on */ -var22 = var17->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ -if (unlikely(var22 == NULL)) { +{ /* Inline model#MClass#name (var18) on */ +var23 = var18->attrs[COLOR_nit__model__MClass___name].val; /* _name on */ +if (unlikely(var23 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 348); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 362); +fatal_exit(1); } -var20 = var22; -RET_LABEL21:(void)0; +var21 = var23; +RET_LABEL22:(void)0; } } -if (varonce) { -var23 = varonce; +if (likely(varonce!=NULL)) { +var24 = varonce; } else { -var24 = "NativeString"; -var25 = 12; -var26 = standard___standard__NativeString___to_s_with_length(var24, var25); -var23 = var26; -varonce = var23; +var25 = "NativeString"; +var26 = standard___standard__NativeString___to_s_with_length(var25, 12l); +var24 = var26; +varonce = var24; } { -{ /* Inline kernel#Object#!= (var20,var23) on */ -var_other29 = var23; +{ /* Inline kernel#Object#!= (var21,var24) on */ +var_other29 = var24; { -var30 = ((short int (*)(val* self, val* p0))(var20->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var20, var_other29) /* == on */; +var30 = ((short int(*)(val* self, val* p0))(var21->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var21, var_other29); /* == on */ } var31 = !var30; var27 = var31; @@ -3399,7 +3195,7 @@ RET_LABEL28:(void)0; } var1 = var27; } else { -var1 = var_16; +var1 = var_17; } if (var1){ { @@ -3407,8 +3203,8 @@ if (var1){ var34 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ if (unlikely(var34 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1059); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1102); +fatal_exit(1); } var32 = var34; RET_LABEL33:(void)0; @@ -3419,8 +3215,8 @@ RET_LABEL33:(void)0; var37 = var32->attrs[COLOR_nit__abstract_compiler__AbstractCompiler___mainmodule].val; /* _mainmodule on */ if (unlikely(var37 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 474); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 515); +fatal_exit(1); } var35 = var37; RET_LABEL36:(void)0; @@ -3439,8 +3235,8 @@ var_res = var39; var43 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ if (unlikely(var43 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1059); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1102); +fatal_exit(1); } var41 = var43; RET_LABEL42:(void)0; @@ -3453,355 +3249,355 @@ var44 = var46; RET_LABEL45:(void)0; } } -var47 = NULL; if (var44 == NULL) { -var48 = 0; /* is null */ +var47 = 0; /* is null */ } else { -var48 = 1; /* arg is null and recv is not */ +var47 = 1; /* arg is null and recv is not */ } if (0) { -{ /* Inline kernel#Object#!= (var44,var47) on */ -var_other29 = var47; +{ /* Inline kernel#Object#!= (var44,((val*)NULL)) on */ +var_other29 = ((val*)NULL); { -var51 = ((short int (*)(val* self, val* p0))(var44->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var44, var_other29) /* == on */; +var50 = ((short int(*)(val* self, val* p0))(var44->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var44, var_other29); /* == on */ } -var52 = !var51; -var49 = var52; -goto RET_LABEL50; -RET_LABEL50:(void)0; +var51 = !var50; +var48 = var51; +goto RET_LABEL49; +RET_LABEL49:(void)0; } -var48 = var49; +var47 = var48; } -var_53 = var48; -if (var48){ +var_52 = var47; +if (var47){ { { /* Inline abstract_compiler#AbstractCompilerVisitor#compiler (self) on */ -var56 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ -if (unlikely(var56 == NULL)) { +var55 = self->attrs[COLOR_nit__abstract_compiler__AbstractCompilerVisitor___compiler].val; /* _compiler on */ +if (unlikely(var55 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _compiler"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1059); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1102); +fatal_exit(1); } -var54 = var56; -RET_LABEL55:(void)0; +var53 = var55; +RET_LABEL54:(void)0; } } { -{ /* Inline separate_compiler#SeparateCompiler#runtime_type_analysis (var54) on */ -var59 = var54->attrs[COLOR_nit__separate_compiler__SeparateCompiler___runtime_type_analysis].val; /* _runtime_type_analysis on */ -var57 = var59; -RET_LABEL58:(void)0; +{ /* Inline separate_compiler#SeparateCompiler#runtime_type_analysis (var53) on */ +var58 = var53->attrs[COLOR_nit__separate_compiler__SeparateCompiler___runtime_type_analysis].val; /* _runtime_type_analysis on */ +var56 = var58; +RET_LABEL57:(void)0; } } -if (var57 == NULL) { +if (var56 == NULL) { PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 611); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 622); +fatal_exit(1); } else { -{ /* Inline rapid_type_analysis#RapidTypeAnalysis#live_types (var57) on */ -if (unlikely(var57 == NULL)) { +{ /* Inline rapid_type_analysis#RapidTypeAnalysis#live_types (var56) on */ +if (unlikely(var56 == NULL)) { PRINT_ERROR("Runtime error: %s", "Receiver is null"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 53); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 60); +fatal_exit(1); } -var62 = var57->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on */ -if (unlikely(var62 == NULL)) { +var61 = var56->attrs[COLOR_nit__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on */ +if (unlikely(var61 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 53); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__rapid_type_analysis, 60); +fatal_exit(1); } -var60 = var62; -RET_LABEL61:(void)0; +var59 = var61; +RET_LABEL60:(void)0; } } { { /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var65 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var65 == NULL)) { +var64 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var64 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1784); +fatal_exit(1); } -var63 = var65; -RET_LABEL64:(void)0; +var62 = var64; +RET_LABEL63:(void)0; } } -/* isa MClassType */ -cltype67 = type_nit__MClassType.color; -idtype68 = type_nit__MClassType.id; -if(cltype67 >= var63->type->table_size) { -var66 = 0; +/* isa MClassType */ +cltype66 = type_nit__MClassType.color; +idtype67 = type_nit__MClassType.id; +if(cltype66 >= var62->type->table_size) { +var65 = 0; } else { -var66 = var63->type->type_table[cltype67] == idtype68; +var65 = var62->type->type_table[cltype66] == idtype67; } -if (unlikely(!var66)) { -var_class_name = var63 == NULL ? "null" : var63->type->name; +if (unlikely(!var65)) { +var_class_name = var62 == NULL ? "null" : var62->type->name; PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 611); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 622); +fatal_exit(1); } { -var69 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var60, var63); +var68 = standard___standard__HashSet___standard__abstract_collection__Collection__has(var59, var62); } -var70 = !var69; -var40 = var70; +var69 = !var68; +var40 = var69; } else { -var40 = var_53; +var40 = var_52; } if (var40){ -if (varonce71) { -var72 = varonce71; +if (unlikely(varonce70==NULL)) { +var71 = NEW_standard__NativeArray(5l, &type_standard__NativeArray__standard__String); +if (likely(varonce72!=NULL)) { +var73 = varonce72; } else { -var73 = "/*no boxing of "; -var74 = 15; -var75 = standard___standard__NativeString___to_s_with_length(var73, var74); -var72 = var75; -varonce71 = var72; -} -{ -{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var78 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var78 == NULL)) { -PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); +var74 = "/*no boxing of "; +var75 = standard___standard__NativeString___to_s_with_length(var74, 15l); +var73 = var75; +varonce72 = var73; } -var76 = var78; -RET_LABEL77:(void)0; +((struct instance_standard__NativeArray*)var71)->values[0]=var73; +if (likely(varonce76!=NULL)) { +var77 = varonce76; +} else { +var78 = ": "; +var79 = standard___standard__NativeString___to_s_with_length(var78, 2l); +var77 = var79; +varonce76 = var77; } +((struct instance_standard__NativeArray*)var71)->values[2]=var77; +if (likely(varonce80!=NULL)) { +var81 = varonce80; +} else { +var82 = " is not live! */"; +var83 = standard___standard__NativeString___to_s_with_length(var82, 16l); +var81 = var83; +varonce80 = var81; } -if (varonce79) { -var80 = varonce79; +((struct instance_standard__NativeArray*)var71)->values[4]=var81; } else { -var81 = ": "; -var82 = 2; -var83 = standard___standard__NativeString___to_s_with_length(var81, var82); -var80 = var83; -varonce79 = var80; +var71 = varonce70; +varonce70 = NULL; } { { /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ var86 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ if (unlikely(var86 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1784); +fatal_exit(1); } var84 = var86; RET_LABEL85:(void)0; } } -if (varonce87) { -var88 = varonce87; -} else { -var89 = " is not live! */"; -var90 = 16; -var91 = standard___standard__NativeString___to_s_with_length(var89, var90); -var88 = var91; -varonce87 = var88; +{ +var87 = ((val*(*)(val* self))(var84->class->vft[COLOR_standard__string__Object__to_s]))(var84); /* to_s on */ } -var92 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var92 = array_instance Array[Object] */ -var93 = 5; -var94 = NEW_standard__NativeArray(var93, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var94)->values[0] = (val*) var72; -((struct instance_standard__NativeArray*)var94)->values[1] = (val*) var76; -((struct instance_standard__NativeArray*)var94)->values[2] = (val*) var80; -((struct instance_standard__NativeArray*)var94)->values[3] = (val*) var84; -((struct instance_standard__NativeArray*)var94)->values[4] = (val*) var88; +((struct instance_standard__NativeArray*)var71)->values[1]=var87; { -((void (*)(val* self, val* p0, long p1))(var92->class->vft[COLOR_standard__array__Array__with_native]))(var92, var94, var93) /* with_native on */; +{ /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ +var90 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var90 == NULL)) { +PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1784); +fatal_exit(1); +} +var88 = var90; +RET_LABEL89:(void)0; } } { -var95 = ((val* (*)(val* self))(var92->class->vft[COLOR_standard__string__Object__to_s]))(var92) /* to_s on */; +var91 = ((val*(*)(val* self))(var88->class->vft[COLOR_standard__string__Object__to_s]))(var88); /* to_s on */ } +((struct instance_standard__NativeArray*)var71)->values[3]=var91; { -nit___nit__AbstractCompilerVisitor___add(self, var95); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +var92 = ((val*(*)(val* self))(var71->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var71); /* native_to_s on */ } -if (varonce96) { -var97 = varonce96; +varonce70 = var71; +{ +nit___nit__AbstractCompilerVisitor___add(self, var92); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +} +if (likely(varonce93!=NULL)) { +var94 = varonce93; } else { -var98 = "PRINT_ERROR(\"Dead code executed!\\n\"); show_backtrace(1);"; -var99 = 56; -var100 = standard___standard__NativeString___to_s_with_length(var98, var99); -var97 = var100; -varonce96 = var97; +var95 = "PRINT_ERROR(\"Dead code executed!\\n\"); fatal_exit(1);"; +var96 = standard___standard__NativeString___to_s_with_length(var95, 52l); +var94 = var96; +varonce93 = var94; } { -nit___nit__AbstractCompilerVisitor___add(self, var97); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var94); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } var = var_res; goto RET_LABEL; } else { } -if (varonce101) { -var102 = varonce101; +if (unlikely(varonce97==NULL)) { +var98 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce99!=NULL)) { +var100 = varonce99; } else { -var103 = "BOX_"; -var104 = 4; -var105 = standard___standard__NativeString___to_s_with_length(var103, var104); -var102 = var105; -varonce101 = var102; +var101 = "BOX_"; +var102 = standard___standard__NativeString___to_s_with_length(var101, 4l); +var100 = var102; +varonce99 = var100; } -{ -var106 = ((val* (*)(val* self))(var_valtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_valtype) /* c_name on */; +((struct instance_standard__NativeArray*)var98)->values[0]=var100; +} else { +var98 = varonce97; +varonce97 = NULL; } -var107 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var107 = array_instance Array[Object] */ -var108 = 2; -var109 = NEW_standard__NativeArray(var108, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var109)->values[0] = (val*) var102; -((struct instance_standard__NativeArray*)var109)->values[1] = (val*) var106; { -((void (*)(val* self, val* p0, long p1))(var107->class->vft[COLOR_standard__array__Array__with_native]))(var107, var109, var108) /* with_native on */; -} +var103 = ((val*(*)(val* self))(var_valtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_valtype); /* c_name on */ } +((struct instance_standard__NativeArray*)var98)->values[1]=var103; { -var110 = ((val* (*)(val* self))(var107->class->vft[COLOR_standard__string__Object__to_s]))(var107) /* to_s on */; +var104 = ((val*(*)(val* self))(var98->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var98); /* native_to_s on */ } +varonce97 = var98; { -nit___nit__AbstractCompilerVisitor___require_declaration(self, var110); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +nit___nit__AbstractCompilerVisitor___require_declaration(self, var104); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +} +if (unlikely(varonce105==NULL)) { +var106 = NEW_standard__NativeArray(8l, &type_standard__NativeArray__standard__String); +if (likely(varonce107!=NULL)) { +var108 = varonce107; +} else { +var109 = " = BOX_"; +var110 = standard___standard__NativeString___to_s_with_length(var109, 7l); +var108 = var110; +varonce107 = var108; } -if (varonce111) { +((struct instance_standard__NativeArray*)var106)->values[1]=var108; +if (likely(varonce111!=NULL)) { var112 = varonce111; } else { -var113 = " = BOX_"; -var114 = 7; -var115 = standard___standard__NativeString___to_s_with_length(var113, var114); -var112 = var115; +var113 = "("; +var114 = standard___standard__NativeString___to_s_with_length(var113, 1l); +var112 = var114; varonce111 = var112; } -{ -var116 = ((val* (*)(val* self))(var_valtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_valtype) /* c_name on */; +((struct instance_standard__NativeArray*)var106)->values[3]=var112; +if (likely(varonce115!=NULL)) { +var116 = varonce115; +} else { +var117 = "); /* boxing "; +var118 = standard___standard__NativeString___to_s_with_length(var117, 13l); +var116 = var118; +varonce115 = var116; } -if (varonce117) { -var118 = varonce117; +((struct instance_standard__NativeArray*)var106)->values[5]=var116; +if (likely(varonce119!=NULL)) { +var120 = varonce119; } else { -var119 = "("; -var120 = 1; -var121 = standard___standard__NativeString___to_s_with_length(var119, var120); -var118 = var121; -varonce117 = var118; +var121 = " */"; +var122 = standard___standard__NativeString___to_s_with_length(var121, 3l); +var120 = var122; +varonce119 = var120; } -if (varonce122) { -var123 = varonce122; +((struct instance_standard__NativeArray*)var106)->values[7]=var120; } else { -var124 = "); /* boxing "; -var125 = 13; -var126 = standard___standard__NativeString___to_s_with_length(var124, var125); -var123 = var126; -varonce122 = var123; +var106 = varonce105; +varonce105 = NULL; } { +var123 = ((val*(*)(val* self))(var_res->class->vft[COLOR_standard__string__Object__to_s]))(var_res); /* to_s on */ +} +((struct instance_standard__NativeArray*)var106)->values[0]=var123; +{ +var124 = ((val*(*)(val* self))(var_valtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_valtype); /* c_name on */ +} +((struct instance_standard__NativeArray*)var106)->values[2]=var124; +{ +var125 = ((val*(*)(val* self))(var_value->class->vft[COLOR_standard__string__Object__to_s]))(var_value); /* to_s on */ +} +((struct instance_standard__NativeArray*)var106)->values[4]=var125; +{ { /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var129 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var129 == NULL)) { +var128 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var128 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1784); +fatal_exit(1); } -var127 = var129; -RET_LABEL128:(void)0; +var126 = var128; +RET_LABEL127:(void)0; } } -if (varonce130) { -var131 = varonce130; -} else { -var132 = " */"; -var133 = 3; -var134 = standard___standard__NativeString___to_s_with_length(var132, var133); -var131 = var134; -varonce130 = var131; -} -var135 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var135 = array_instance Array[Object] */ -var136 = 8; -var137 = NEW_standard__NativeArray(var136, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var137)->values[0] = (val*) var_res; -((struct instance_standard__NativeArray*)var137)->values[1] = (val*) var112; -((struct instance_standard__NativeArray*)var137)->values[2] = (val*) var116; -((struct instance_standard__NativeArray*)var137)->values[3] = (val*) var118; -((struct instance_standard__NativeArray*)var137)->values[4] = (val*) var_value; -((struct instance_standard__NativeArray*)var137)->values[5] = (val*) var123; -((struct instance_standard__NativeArray*)var137)->values[6] = (val*) var127; -((struct instance_standard__NativeArray*)var137)->values[7] = (val*) var131; { -((void (*)(val* self, val* p0, long p1))(var135->class->vft[COLOR_standard__array__Array__with_native]))(var135, var137, var136) /* with_native on */; -} +var129 = ((val*(*)(val* self))(var126->class->vft[COLOR_standard__string__Object__to_s]))(var126); /* to_s on */ } +((struct instance_standard__NativeArray*)var106)->values[6]=var129; { -var138 = ((val* (*)(val* self))(var135->class->vft[COLOR_standard__string__Object__to_s]))(var135) /* to_s on */; +var130 = ((val*(*)(val* self))(var106->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var106); /* native_to_s on */ } +varonce105 = var106; { -nit___nit__AbstractCompilerVisitor___add(self, var138); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var130); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } -if (varonce139) { -var140 = varonce139; +if (unlikely(varonce131==NULL)) { +var132 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce133!=NULL)) { +var134 = varonce133; } else { -var141 = "class_"; -var142 = 6; -var143 = standard___standard__NativeString___to_s_with_length(var141, var142); -var140 = var143; -varonce139 = var140; +var135 = "class_"; +var136 = standard___standard__NativeString___to_s_with_length(var135, 6l); +var134 = var136; +varonce133 = var134; } -{ -var144 = ((val* (*)(val* self))(var_mtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_mtype) /* c_name on */; +((struct instance_standard__NativeArray*)var132)->values[0]=var134; +} else { +var132 = varonce131; +varonce131 = NULL; } -var145 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var145 = array_instance Array[Object] */ -var146 = 2; -var147 = NEW_standard__NativeArray(var146, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var147)->values[0] = (val*) var140; -((struct instance_standard__NativeArray*)var147)->values[1] = (val*) var144; { -((void (*)(val* self, val* p0, long p1))(var145->class->vft[COLOR_standard__array__Array__with_native]))(var145, var147, var146) /* with_native on */; -} +var137 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_mtype); /* c_name on */ } +((struct instance_standard__NativeArray*)var132)->values[1]=var137; { -var148 = ((val* (*)(val* self))(var145->class->vft[COLOR_standard__string__Object__to_s]))(var145) /* to_s on */; +var138 = ((val*(*)(val* self))(var132->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var132); /* native_to_s on */ } +varonce131 = var132; { -nit___nit__AbstractCompilerVisitor___require_declaration(self, var148); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +nit___nit__AbstractCompilerVisitor___require_declaration(self, var138); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ } -if (varonce149) { -var150 = varonce149; +if (unlikely(varonce139==NULL)) { +var140 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce141!=NULL)) { +var142 = varonce141; } else { -var151 = "->class = &class_"; -var152 = 17; -var153 = standard___standard__NativeString___to_s_with_length(var151, var152); -var150 = var153; -varonce149 = var150; +var143 = "->class = &class_"; +var144 = standard___standard__NativeString___to_s_with_length(var143, 17l); +var142 = var144; +varonce141 = var142; } -{ -var154 = ((val* (*)(val* self))(var_mtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_mtype) /* c_name on */; +((struct instance_standard__NativeArray*)var140)->values[1]=var142; +if (likely(varonce145!=NULL)) { +var146 = varonce145; +} else { +var147 = ";"; +var148 = standard___standard__NativeString___to_s_with_length(var147, 1l); +var146 = var148; +varonce145 = var146; } -if (varonce155) { -var156 = varonce155; +((struct instance_standard__NativeArray*)var140)->values[3]=var146; } else { -var157 = ";"; -var158 = 1; -var159 = standard___standard__NativeString___to_s_with_length(var157, var158); -var156 = var159; -varonce155 = var156; +var140 = varonce139; +varonce139 = NULL; } -var160 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var160 = array_instance Array[Object] */ -var161 = 4; -var162 = NEW_standard__NativeArray(var161, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var162)->values[0] = (val*) var_res; -((struct instance_standard__NativeArray*)var162)->values[1] = (val*) var150; -((struct instance_standard__NativeArray*)var162)->values[2] = (val*) var154; -((struct instance_standard__NativeArray*)var162)->values[3] = (val*) var156; { -((void (*)(val* self, val* p0, long p1))(var160->class->vft[COLOR_standard__array__Array__with_native]))(var160, var162, var161) /* with_native on */; +var149 = ((val*(*)(val* self))(var_res->class->vft[COLOR_standard__string__Object__to_s]))(var_res); /* to_s on */ } +((struct instance_standard__NativeArray*)var140)->values[0]=var149; +{ +var150 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var_mtype); /* c_name on */ } +((struct instance_standard__NativeArray*)var140)->values[2]=var150; { -var163 = ((val* (*)(val* self))(var160->class->vft[COLOR_standard__string__Object__to_s]))(var160) /* to_s on */; +var151 = ((val*(*)(val* self))(var140->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var140); /* native_to_s on */ } +varonce139 = var140; { -nit___nit__AbstractCompilerVisitor___add(self, var163); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var151); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } var = var_res; goto RET_LABEL; @@ -3819,296 +3615,262 @@ val* var_value /* var value: RuntimeVariable */; static val* varonce; val* var1 /* : String */; char* var2 /* : NativeString */; -long var3 /* : Int */; -val* var4 /* : FlatString */; -val* var5 /* : String */; +val* var3 /* : FlatString */; +val* var4 /* : String */; val* var_res /* var res: String */; -static val* varonce6; -val* var7 /* : String */; -char* var8 /* : NativeString */; -long var9 /* : Int */; +val* var6 /* : NativeArray[String] */; +static val* varonce5; +static val* varonce7; +val* var8 /* : String */; +char* var9 /* : NativeString */; val* var10 /* : FlatString */; static val* varonce11; val* var12 /* : String */; char* var13 /* : NativeString */; -long var14 /* : Int */; -val* var15 /* : FlatString */; -val* var16 /* : Array[Object] */; -long var17 /* : Int */; -val* var18 /* : NativeArray[Object] */; -val* var19 /* : String */; -val* var20 /* : MType */; -val* var22 /* : MType */; -val* var23 /* : String */; -static val* varonce24; -val* var25 /* : String */; -char* var26 /* : NativeString */; -long var27 /* : Int */; -val* var28 /* : FlatString */; -short int var29 /* : Bool */; -static val* varonce30; -val* var31 /* : String */; -char* var32 /* : NativeString */; -long var33 /* : Int */; +val* var14 /* : FlatString */; +val* var15 /* : String */; +val* var16 /* : MType */; +val* var18 /* : MType */; +short int var19 /* : Bool */; +short int var20 /* : Bool */; +val* var22 /* : NativeArray[String] */; +static val* varonce21; +static val* varonce23; +val* var24 /* : String */; +char* var25 /* : NativeString */; +val* var26 /* : FlatString */; +static val* varonce27; +val* var28 /* : String */; +char* var29 /* : NativeString */; +val* var30 /* : FlatString */; +static val* varonce31; +val* var32 /* : String */; +char* var33 /* : NativeString */; val* var34 /* : FlatString */; -static val* varonce35; +val* var35 /* : String */; val* var36 /* : String */; -char* var37 /* : NativeString */; -long var38 /* : Int */; -val* var39 /* : FlatString */; +val* var37 /* : String */; +val* var39 /* : NativeArray[String] */; +static val* varonce38; static val* varonce40; val* var41 /* : String */; char* var42 /* : NativeString */; -long var43 /* : Int */; -val* var44 /* : FlatString */; -val* var45 /* : Array[Object] */; -long var46 /* : Int */; -val* var47 /* : NativeArray[Object] */; +val* var43 /* : FlatString */; +val* var44 /* : MType */; +val* var46 /* : MType */; +val* var47 /* : String */; val* var48 /* : String */; +val* var50 /* : NativeArray[String] */; static val* varonce49; -val* var50 /* : String */; -char* var51 /* : NativeString */; -long var52 /* : Int */; -val* var53 /* : FlatString */; -val* var54 /* : MType */; -val* var56 /* : MType */; -val* var57 /* : String */; -val* var58 /* : Array[Object] */; -long var59 /* : Int */; -val* var60 /* : NativeArray[Object] */; -val* var61 /* : String */; -static val* varonce62; +static val* varonce51; +val* var52 /* : String */; +char* var53 /* : NativeString */; +val* var54 /* : FlatString */; +static val* varonce55; +val* var56 /* : String */; +char* var57 /* : NativeString */; +val* var58 /* : FlatString */; +val* var59 /* : MType */; +val* var61 /* : MType */; +val* var62 /* : String */; val* var63 /* : String */; -char* var64 /* : NativeString */; -long var65 /* : Int */; -val* var66 /* : FlatString */; -val* var67 /* : MType */; -val* var69 /* : MType */; -val* var70 /* : String */; -static val* varonce71; -val* var72 /* : String */; -char* var73 /* : NativeString */; -long var74 /* : Int */; -val* var75 /* : FlatString */; -val* var76 /* : Array[Object] */; -long var77 /* : Int */; -val* var78 /* : NativeArray[Object] */; -val* var79 /* : String */; var_value = p0; -if (varonce) { +if (likely(varonce!=NULL)) { var1 = varonce; } else { var2 = "var_class_name"; -var3 = 14; -var4 = standard___standard__NativeString___to_s_with_length(var2, var3); -var1 = var4; +var3 = standard___standard__NativeString___to_s_with_length(var2, 14l); +var1 = var3; varonce = var1; } { -var5 = nit___nit__AbstractCompilerVisitor___get_name(self, var1); +var4 = nit___nit__AbstractCompilerVisitor___get_name(self, var1); } -var_res = var5; -if (varonce6) { -var7 = varonce6; +var_res = var4; +if (unlikely(varonce5==NULL)) { +var6 = NEW_standard__NativeArray(3l, &type_standard__NativeArray__standard__String); +if (likely(varonce7!=NULL)) { +var8 = varonce7; } else { -var8 = "const char* "; -var9 = 12; -var10 = standard___standard__NativeString___to_s_with_length(var8, var9); -var7 = var10; -varonce6 = var7; +var9 = "const char* "; +var10 = standard___standard__NativeString___to_s_with_length(var9, 12l); +var8 = var10; +varonce7 = var8; } -if (varonce11) { +((struct instance_standard__NativeArray*)var6)->values[0]=var8; +if (likely(varonce11!=NULL)) { var12 = varonce11; } else { var13 = ";"; -var14 = 1; -var15 = standard___standard__NativeString___to_s_with_length(var13, var14); -var12 = var15; +var14 = standard___standard__NativeString___to_s_with_length(var13, 1l); +var12 = var14; varonce11 = var12; } -var16 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var16 = array_instance Array[Object] */ -var17 = 3; -var18 = NEW_standard__NativeArray(var17, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var18)->values[0] = (val*) var7; -((struct instance_standard__NativeArray*)var18)->values[1] = (val*) var_res; -((struct instance_standard__NativeArray*)var18)->values[2] = (val*) var12; -{ -((void (*)(val* self, val* p0, long p1))(var16->class->vft[COLOR_standard__array__Array__with_native]))(var16, var18, var17) /* with_native on */; -} +((struct instance_standard__NativeArray*)var6)->values[2]=var12; +} else { +var6 = varonce5; +varonce5 = NULL; } +((struct instance_standard__NativeArray*)var6)->values[1]=var_res; { -var19 = ((val* (*)(val* self))(var16->class->vft[COLOR_standard__string__Object__to_s]))(var16) /* to_s on */; +var15 = ((val*(*)(val* self))(var6->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var6); /* native_to_s on */ } +varonce5 = var6; { -nit___nit__AbstractCompilerVisitor___add_decl(self, var19); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ +nit___nit__AbstractCompilerVisitor___add_decl(self, var15); /* Direct call abstract_compiler#AbstractCompilerVisitor#add_decl on */ } { { /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var22 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var22 == NULL)) { +var18 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var18 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1784); +fatal_exit(1); } -var20 = var22; -RET_LABEL21:(void)0; +var16 = var18; +RET_LABEL17:(void)0; } } { -var23 = ((val* (*)(val* self))(var20->class->vft[COLOR_nit__abstract_compiler__MType__ctype]))(var20) /* ctype on */; +var19 = ((short int(*)(val* self))(var16->class->vft[COLOR_nit__abstract_compiler__MType__is_c_primitive]))(var16); /* is_c_primitive on */ } -if (varonce24) { -var25 = varonce24; +var20 = !var19; +if (var20){ +if (unlikely(varonce21==NULL)) { +var22 = NEW_standard__NativeArray(6l, &type_standard__NativeArray__standard__String); +if (likely(varonce23!=NULL)) { +var24 = varonce23; } else { -var26 = "val*"; -var27 = 4; -var28 = standard___standard__NativeString___to_s_with_length(var26, var27); -var25 = var28; -varonce24 = var25; -} -{ -var29 = ((short int (*)(val* self, val* p0))(var23->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var23, var25) /* == on */; +var25 = " = "; +var26 = standard___standard__NativeString___to_s_with_length(var25, 3l); +var24 = var26; +varonce23 = var24; } -if (var29){ -if (varonce30) { -var31 = varonce30; +((struct instance_standard__NativeArray*)var22)->values[1]=var24; +if (likely(varonce27!=NULL)) { +var28 = varonce27; } else { -var32 = " = "; -var33 = 3; -var34 = standard___standard__NativeString___to_s_with_length(var32, var33); -var31 = var34; -varonce30 = var31; +var29 = " == NULL ? \"null\" : "; +var30 = standard___standard__NativeString___to_s_with_length(var29, 20l); +var28 = var30; +varonce27 = var28; } -if (varonce35) { -var36 = varonce35; +((struct instance_standard__NativeArray*)var22)->values[3]=var28; +if (likely(varonce31!=NULL)) { +var32 = varonce31; } else { -var37 = " == NULL ? \"null\" : "; -var38 = 20; -var39 = standard___standard__NativeString___to_s_with_length(var37, var38); -var36 = var39; -varonce35 = var36; +var33 = "->class->name;"; +var34 = standard___standard__NativeString___to_s_with_length(var33, 14l); +var32 = var34; +varonce31 = var32; } -if (varonce40) { -var41 = varonce40; +((struct instance_standard__NativeArray*)var22)->values[5]=var32; } else { -var42 = "->class->name;"; -var43 = 14; -var44 = standard___standard__NativeString___to_s_with_length(var42, var43); -var41 = var44; -varonce40 = var41; +var22 = varonce21; +varonce21 = NULL; } -var45 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var45 = array_instance Array[Object] */ -var46 = 6; -var47 = NEW_standard__NativeArray(var46, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var47)->values[0] = (val*) var_res; -((struct instance_standard__NativeArray*)var47)->values[1] = (val*) var31; -((struct instance_standard__NativeArray*)var47)->values[2] = (val*) var_value; -((struct instance_standard__NativeArray*)var47)->values[3] = (val*) var36; -((struct instance_standard__NativeArray*)var47)->values[4] = (val*) var_value; -((struct instance_standard__NativeArray*)var47)->values[5] = (val*) var41; +((struct instance_standard__NativeArray*)var22)->values[0]=var_res; { -((void (*)(val* self, val* p0, long p1))(var45->class->vft[COLOR_standard__array__Array__with_native]))(var45, var47, var46) /* with_native on */; +var35 = ((val*(*)(val* self))(var_value->class->vft[COLOR_standard__string__Object__to_s]))(var_value); /* to_s on */ } +((struct instance_standard__NativeArray*)var22)->values[2]=var35; +{ +var36 = ((val*(*)(val* self))(var_value->class->vft[COLOR_standard__string__Object__to_s]))(var_value); /* to_s on */ } +((struct instance_standard__NativeArray*)var22)->values[4]=var36; { -var48 = ((val* (*)(val* self))(var45->class->vft[COLOR_standard__string__Object__to_s]))(var45) /* to_s on */; +var37 = ((val*(*)(val* self))(var22->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var22); /* native_to_s on */ } +varonce21 = var22; { -nit___nit__AbstractCompilerVisitor___add(self, var48); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var37); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } } else { -if (varonce49) { -var50 = varonce49; +if (unlikely(varonce38==NULL)) { +var39 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce40!=NULL)) { +var41 = varonce40; } else { -var51 = "class_"; -var52 = 6; -var53 = standard___standard__NativeString___to_s_with_length(var51, var52); -var50 = var53; -varonce49 = var50; +var42 = "class_"; +var43 = standard___standard__NativeString___to_s_with_length(var42, 6l); +var41 = var43; +varonce40 = var41; +} +((struct instance_standard__NativeArray*)var39)->values[0]=var41; +} else { +var39 = varonce38; +varonce38 = NULL; } { { /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var56 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var56 == NULL)) { +var46 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var46 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1784); +fatal_exit(1); } -var54 = var56; -RET_LABEL55:(void)0; +var44 = var46; +RET_LABEL45:(void)0; } } { -var57 = ((val* (*)(val* self))(var54->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var54) /* c_name on */; +var47 = ((val*(*)(val* self))(var44->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var44); /* c_name on */ } -var58 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var58 = array_instance Array[Object] */ -var59 = 2; -var60 = NEW_standard__NativeArray(var59, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var60)->values[0] = (val*) var50; -((struct instance_standard__NativeArray*)var60)->values[1] = (val*) var57; +((struct instance_standard__NativeArray*)var39)->values[1]=var47; { -((void (*)(val* self, val* p0, long p1))(var58->class->vft[COLOR_standard__array__Array__with_native]))(var58, var60, var59) /* with_native on */; -} +var48 = ((val*(*)(val* self))(var39->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var39); /* native_to_s on */ } +varonce38 = var39; { -var61 = ((val* (*)(val* self))(var58->class->vft[COLOR_standard__string__Object__to_s]))(var58) /* to_s on */; +nit___nit__AbstractCompilerVisitor___require_declaration(self, var48); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ } -{ -nit___nit__AbstractCompilerVisitor___require_declaration(self, var61); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +if (unlikely(varonce49==NULL)) { +var50 = NEW_standard__NativeArray(4l, &type_standard__NativeArray__standard__String); +if (likely(varonce51!=NULL)) { +var52 = varonce51; +} else { +var53 = " = class_"; +var54 = standard___standard__NativeString___to_s_with_length(var53, 9l); +var52 = var54; +varonce51 = var52; } -if (varonce62) { -var63 = varonce62; +((struct instance_standard__NativeArray*)var50)->values[1]=var52; +if (likely(varonce55!=NULL)) { +var56 = varonce55; } else { -var64 = " = class_"; -var65 = 9; -var66 = standard___standard__NativeString___to_s_with_length(var64, var65); -var63 = var66; -varonce62 = var63; +var57 = ".name;"; +var58 = standard___standard__NativeString___to_s_with_length(var57, 6l); +var56 = var58; +varonce55 = var56; } +((struct instance_standard__NativeArray*)var50)->values[3]=var56; +} else { +var50 = varonce49; +varonce49 = NULL; +} +((struct instance_standard__NativeArray*)var50)->values[0]=var_res; { { /* Inline abstract_compiler#RuntimeVariable#mtype (var_value) on */ -var69 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ -if (unlikely(var69 == NULL)) { +var61 = var_value->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___mtype].val; /* _mtype on */ +if (unlikely(var61 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1680); -show_backtrace(1); -} -var67 = var69; -RET_LABEL68:(void)0; +PRINT_ERROR(" (%s:%d)\n", FILE_nit__abstract_compiler, 1784); +fatal_exit(1); } +var59 = var61; +RET_LABEL60:(void)0; } -{ -var70 = ((val* (*)(val* self))(var67->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var67) /* c_name on */; -} -if (varonce71) { -var72 = varonce71; -} else { -var73 = ".name;"; -var74 = 6; -var75 = standard___standard__NativeString___to_s_with_length(var73, var74); -var72 = var75; -varonce71 = var72; } -var76 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var76 = array_instance Array[Object] */ -var77 = 4; -var78 = NEW_standard__NativeArray(var77, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var78)->values[0] = (val*) var_res; -((struct instance_standard__NativeArray*)var78)->values[1] = (val*) var63; -((struct instance_standard__NativeArray*)var78)->values[2] = (val*) var70; -((struct instance_standard__NativeArray*)var78)->values[3] = (val*) var72; { -((void (*)(val* self, val* p0, long p1))(var76->class->vft[COLOR_standard__array__Array__with_native]))(var76, var78, var77) /* with_native on */; -} +var62 = ((val*(*)(val* self))(var59->class->vft[COLOR_nit__model_base__MEntity__c_name]))(var59); /* c_name on */ } +((struct instance_standard__NativeArray*)var50)->values[2]=var62; { -var79 = ((val* (*)(val* self))(var76->class->vft[COLOR_standard__string__Object__to_s]))(var76) /* to_s on */; +var63 = ((val*(*)(val* self))(var50->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var50); /* native_to_s on */ } +varonce49 = var50; { -nit___nit__AbstractCompilerVisitor___add(self, var79); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var63); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } } var = var_res; @@ -4121,167 +3883,149 @@ val* nit___nit__SeparateErasureCompilerVisitor___nit__abstract_compiler__Abstrac val* var /* : RuntimeVariable */; val* var_elttype /* var elttype: MType */; val* var_length /* var length: RuntimeVariable */; -static val* varonce; -val* var1 /* : String */; -char* var2 /* : NativeString */; -long var3 /* : Int */; -val* var4 /* : FlatString */; -val* var5 /* : MClass */; +val* var1 /* : MModule */; +val* var2 /* : MClass */; val* var_nclass /* var nclass: MClass */; -val* var6 /* : Array[MType] */; -long var7 /* : Int */; +val* var3 /* : Array[MType] */; val* var_ /* var : Array[MType] */; -val* var8 /* : MClassType */; +val* var4 /* : MClassType */; val* var_mtype /* var mtype: MClassType */; -val* var9 /* : RuntimeVariable */; +val* var5 /* : RuntimeVariable */; val* var_res /* var res: RuntimeVariable */; -short int var10 /* : Bool */; -static val* varonce12; +val* var7 /* : NativeArray[String] */; +static val* varonce; +static val* varonce8; +val* var9 /* : String */; +char* var10 /* : NativeString */; +val* var11 /* : FlatString */; +val* var12 /* : String */; val* var13 /* : String */; -char* var14 /* : NativeString */; -long var15 /* : Int */; -val* var16 /* : FlatString */; +val* var15 /* : NativeArray[String] */; +static val* varonce14; +static val* varonce16; val* var17 /* : String */; -val* var18 /* : Array[Object] */; -long var19 /* : Int */; -val* var20 /* : NativeArray[Object] */; +char* var18 /* : NativeString */; +val* var19 /* : FlatString */; +static val* varonce20; val* var21 /* : String */; -static val* varonce22; -val* var23 /* : String */; -char* var24 /* : NativeString */; -long var25 /* : Int */; -val* var26 /* : FlatString */; -val* var27 /* : String */; -static val* varonce28; +char* var22 /* : NativeString */; +val* var23 /* : FlatString */; +static val* varonce24; +val* var25 /* : String */; +char* var26 /* : NativeString */; +val* var27 /* : FlatString */; +val* var28 /* : String */; val* var29 /* : String */; -char* var30 /* : NativeString */; -long var31 /* : Int */; -val* var32 /* : FlatString */; -static val* varonce33; -val* var34 /* : String */; -char* var35 /* : NativeString */; -long var36 /* : Int */; -val* var37 /* : FlatString */; -val* var38 /* : Array[Object] */; -long var39 /* : Int */; -val* var40 /* : NativeArray[Object] */; -val* var41 /* : String */; +val* var30 /* : String */; +val* var31 /* : String */; var_elttype = p0; var_length = p1; -if (varonce) { -var1 = varonce; -} else { -var2 = "NativeArray"; -var3 = 11; -var4 = standard___standard__NativeString___to_s_with_length(var2, var3); -var1 = var4; -varonce = var1; +{ +var1 = nit___nit__AbstractCompilerVisitor___mmodule(self); } { -var5 = nit___nit__AbstractCompilerVisitor___get_class(self, var1); +var2 = nit__model___MModule___native_array_class(var1); } -var_nclass = var5; -var6 = NEW_standard__Array(&type_standard__Array__nit__MType); -var7 = 1; +var_nclass = var2; +var3 = NEW_standard__Array(&type_standard__Array__nit__MType); { -standard___standard__Array___with_capacity(var6, var7); /* Direct call array#Array#with_capacity on */ +standard___standard__Array___with_capacity(var3, 1l); /* Direct call array#Array#with_capacity on */ } -var_ = var6; +var_ = var3; { standard___standard__AbstractArray___standard__abstract_collection__Sequence__push(var_, var_elttype); /* Direct call array#AbstractArray#push on */ } { -var8 = nit___nit__MClass___get_mtype(var_nclass, var_); +var4 = nit___nit__MClass___get_mtype(var_nclass, var_); } -var_mtype = var8; +var_mtype = var4; { -var9 = nit___nit__AbstractCompilerVisitor___new_var(self, var_mtype); +var5 = nit___nit__AbstractCompilerVisitor___new_var(self, var_mtype); } -var_res = var9; -var10 = 1; +var_res = var5; { -{ /* Inline abstract_compiler#RuntimeVariable#is_exact= (var_res,var10) on */ -var_res->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___is_exact].s = var10; /* _is_exact on */ -RET_LABEL11:(void)0; +{ /* Inline abstract_compiler#RuntimeVariable#is_exact= (var_res,1) on */ +var_res->attrs[COLOR_nit__abstract_compiler__RuntimeVariable___is_exact].s = 1; /* _is_exact on */ +RET_LABEL6:(void)0; } } -if (varonce12) { -var13 = varonce12; +if (unlikely(varonce==NULL)) { +var7 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce8!=NULL)) { +var9 = varonce8; } else { -var14 = "NEW_"; -var15 = 4; -var16 = standard___standard__NativeString___to_s_with_length(var14, var15); -var13 = var16; -varonce12 = var13; +var10 = "NEW_"; +var11 = standard___standard__NativeString___to_s_with_length(var10, 4l); +var9 = var11; +varonce8 = var9; } -{ -var17 = nit___nit__MClass___nit__model_base__MEntity__c_name(var_nclass); +((struct instance_standard__NativeArray*)var7)->values[0]=var9; +} else { +var7 = varonce; +varonce = NULL; } -var18 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var18 = array_instance Array[Object] */ -var19 = 2; -var20 = NEW_standard__NativeArray(var19, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var20)->values[0] = (val*) var13; -((struct instance_standard__NativeArray*)var20)->values[1] = (val*) var17; { -((void (*)(val* self, val* p0, long p1))(var18->class->vft[COLOR_standard__array__Array__with_native]))(var18, var20, var19) /* with_native on */; -} +var12 = nit___nit__MClass___nit__model_base__MEntity__c_name(var_nclass); } +((struct instance_standard__NativeArray*)var7)->values[1]=var12; { -var21 = ((val* (*)(val* self))(var18->class->vft[COLOR_standard__string__Object__to_s]))(var18) /* to_s on */; +var13 = ((val*(*)(val* self))(var7->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var7); /* native_to_s on */ } +varonce = var7; { -nit___nit__AbstractCompilerVisitor___require_declaration(self, var21); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +nit___nit__AbstractCompilerVisitor___require_declaration(self, var13); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ } -if (varonce22) { -var23 = varonce22; +if (unlikely(varonce14==NULL)) { +var15 = NEW_standard__NativeArray(6l, &type_standard__NativeArray__standard__String); +if (likely(varonce16!=NULL)) { +var17 = varonce16; } else { -var24 = " = NEW_"; -var25 = 7; -var26 = standard___standard__NativeString___to_s_with_length(var24, var25); -var23 = var26; -varonce22 = var23; +var18 = " = NEW_"; +var19 = standard___standard__NativeString___to_s_with_length(var18, 7l); +var17 = var19; +varonce16 = var17; } -{ -var27 = nit___nit__MClass___nit__model_base__MEntity__c_name(var_nclass); +((struct instance_standard__NativeArray*)var15)->values[1]=var17; +if (likely(varonce20!=NULL)) { +var21 = varonce20; +} else { +var22 = "("; +var23 = standard___standard__NativeString___to_s_with_length(var22, 1l); +var21 = var23; +varonce20 = var21; } -if (varonce28) { -var29 = varonce28; +((struct instance_standard__NativeArray*)var15)->values[3]=var21; +if (likely(varonce24!=NULL)) { +var25 = varonce24; } else { -var30 = "("; -var31 = 1; -var32 = standard___standard__NativeString___to_s_with_length(var30, var31); -var29 = var32; -varonce28 = var29; +var26 = ");"; +var27 = standard___standard__NativeString___to_s_with_length(var26, 2l); +var25 = var27; +varonce24 = var25; } -if (varonce33) { -var34 = varonce33; +((struct instance_standard__NativeArray*)var15)->values[5]=var25; } else { -var35 = ");"; -var36 = 2; -var37 = standard___standard__NativeString___to_s_with_length(var35, var36); -var34 = var37; -varonce33 = var34; +var15 = varonce14; +varonce14 = NULL; } -var38 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var38 = array_instance Array[Object] */ -var39 = 6; -var40 = NEW_standard__NativeArray(var39, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var40)->values[0] = (val*) var_res; -((struct instance_standard__NativeArray*)var40)->values[1] = (val*) var23; -((struct instance_standard__NativeArray*)var40)->values[2] = (val*) var27; -((struct instance_standard__NativeArray*)var40)->values[3] = (val*) var29; -((struct instance_standard__NativeArray*)var40)->values[4] = (val*) var_length; -((struct instance_standard__NativeArray*)var40)->values[5] = (val*) var34; { -((void (*)(val* self, val* p0, long p1))(var38->class->vft[COLOR_standard__array__Array__with_native]))(var38, var40, var39) /* with_native on */; +var28 = ((val*(*)(val* self))(var_res->class->vft[COLOR_standard__string__Object__to_s]))(var_res); /* to_s on */ } +((struct instance_standard__NativeArray*)var15)->values[0]=var28; +{ +var29 = nit___nit__MClass___nit__model_base__MEntity__c_name(var_nclass); +} +((struct instance_standard__NativeArray*)var15)->values[2]=var29; +{ +var30 = ((val*(*)(val* self))(var_length->class->vft[COLOR_standard__string__Object__to_s]))(var_length); /* to_s on */ } +((struct instance_standard__NativeArray*)var15)->values[4]=var30; { -var41 = ((val* (*)(val* self))(var38->class->vft[COLOR_standard__string__Object__to_s]))(var38) /* to_s on */; +var31 = ((val*(*)(val* self))(var15->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var15); /* native_to_s on */ } +varonce14 = var15; { -nit___nit__AbstractCompilerVisitor___add(self, var41); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ +nit___nit__AbstractCompilerVisitor___add(self, var31); /* Direct call abstract_compiler#AbstractCompilerVisitor#add on */ } var = var_res; goto RET_LABEL; @@ -4297,43 +4041,37 @@ int cltype; int idtype; const char* var_class_name; val* var_ret /* var ret: MClassType */; +val* var1 /* : NativeArray[String] */; static val* varonce; -val* var1 /* : String */; -char* var2 /* : NativeString */; -long var3 /* : Int */; -val* var4 /* : FlatString */; -val* var5 /* : MClass */; -val* var7 /* : MClass */; -val* var8 /* : String */; -val* var9 /* : Array[Object] */; -long var10 /* : Int */; -val* var11 /* : NativeArray[Object] */; -val* var12 /* : String */; +static val* varonce2; +val* var3 /* : String */; +char* var4 /* : NativeString */; +val* var5 /* : FlatString */; +val* var6 /* : MClass */; +val* var8 /* : MClass */; +val* var9 /* : String */; +val* var10 /* : String */; +val* var12 /* : NativeArray[String] */; +static val* varonce11; static val* varonce13; val* var14 /* : String */; char* var15 /* : NativeString */; -long var16 /* : Int */; -val* var17 /* : FlatString */; -val* var18 /* : MClass */; -val* var20 /* : MClass */; -val* var21 /* : String */; -static val* varonce22; -val* var23 /* : String */; -char* var24 /* : NativeString */; -long var25 /* : Int */; -val* var26 /* : FlatString */; -long var27 /* : Int */; -val* var28 /* : nullable Object */; -static val* varonce29; +val* var16 /* : FlatString */; +static val* varonce17; +val* var18 /* : String */; +char* var19 /* : NativeString */; +val* var20 /* : FlatString */; +static val* varonce21; +val* var22 /* : String */; +char* var23 /* : NativeString */; +val* var24 /* : FlatString */; +val* var25 /* : MClass */; +val* var27 /* : MClass */; +val* var28 /* : String */; +val* var29 /* : nullable Object */; val* var30 /* : String */; -char* var31 /* : NativeString */; -long var32 /* : Int */; -val* var33 /* : FlatString */; -val* var34 /* : Array[Object] */; -long var35 /* : Int */; -val* var36 /* : NativeArray[Object] */; -val* var37 /* : String */; -val* var38 /* : RuntimeVariable */; +val* var31 /* : String */; +val* var32 /* : RuntimeVariable */; var_ret_type = p0; var_arguments = p1; /* isa MClassType */ @@ -4347,117 +4085,113 @@ var = var_ret_type->type->type_table[cltype] == idtype; if (unlikely(!var)) { var_class_name = var_ret_type == NULL ? "null" : var_ret_type->type->name; PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 652); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__separate_erasure_compiler, 663); +fatal_exit(1); } var_ret = var_ret_type; -if (varonce) { -var1 = varonce; +if (unlikely(varonce==NULL)) { +var1 = NEW_standard__NativeArray(2l, &type_standard__NativeArray__standard__String); +if (likely(varonce2!=NULL)) { +var3 = varonce2; } else { -var2 = "NEW_"; -var3 = 4; -var4 = standard___standard__NativeString___to_s_with_length(var2, var3); -var1 = var4; -varonce = var1; +var4 = "NEW_"; +var5 = standard___standard__NativeString___to_s_with_length(var4, 4l); +var3 = var5; +varonce2 = var3; +} +((struct instance_standard__NativeArray*)var1)->values[0]=var3; +} else { +var1 = varonce; +varonce = NULL; } { { /* Inline model#MClassType#mclass (var_ret) on */ -var7 = var_ret->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var7 == NULL)) { +var8 = var_ret->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var8 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1058); -show_backtrace(1); -} -var5 = var7; -RET_LABEL6:(void)0; +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138); +fatal_exit(1); } +var6 = var8; +RET_LABEL7:(void)0; } -{ -var8 = nit___nit__MClass___nit__model_base__MEntity__c_name(var5); } -var9 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var9 = array_instance Array[Object] */ -var10 = 2; -var11 = NEW_standard__NativeArray(var10, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var11)->values[0] = (val*) var1; -((struct instance_standard__NativeArray*)var11)->values[1] = (val*) var8; { -((void (*)(val* self, val* p0, long p1))(var9->class->vft[COLOR_standard__array__Array__with_native]))(var9, var11, var10) /* with_native on */; -} +var9 = nit___nit__MClass___nit__model_base__MEntity__c_name(var6); } +((struct instance_standard__NativeArray*)var1)->values[1]=var9; { -var12 = ((val* (*)(val* self))(var9->class->vft[COLOR_standard__string__Object__to_s]))(var9) /* to_s on */; +var10 = ((val*(*)(val* self))(var1->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var1); /* native_to_s on */ } +varonce = var1; { -nit___nit__AbstractCompilerVisitor___require_declaration(self, var12); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ +nit___nit__AbstractCompilerVisitor___require_declaration(self, var10); /* Direct call abstract_compiler#AbstractCompilerVisitor#require_declaration on */ } -if (varonce13) { +if (unlikely(varonce11==NULL)) { +var12 = NEW_standard__NativeArray(5l, &type_standard__NativeArray__standard__String); +if (likely(varonce13!=NULL)) { var14 = varonce13; } else { var15 = "NEW_"; -var16 = 4; -var17 = standard___standard__NativeString___to_s_with_length(var15, var16); -var14 = var17; +var16 = standard___standard__NativeString___to_s_with_length(var15, 4l); +var14 = var16; varonce13 = var14; } +((struct instance_standard__NativeArray*)var12)->values[0]=var14; +if (likely(varonce17!=NULL)) { +var18 = varonce17; +} else { +var19 = "("; +var20 = standard___standard__NativeString___to_s_with_length(var19, 1l); +var18 = var20; +varonce17 = var18; +} +((struct instance_standard__NativeArray*)var12)->values[2]=var18; +if (likely(varonce21!=NULL)) { +var22 = varonce21; +} else { +var23 = ")"; +var24 = standard___standard__NativeString___to_s_with_length(var23, 1l); +var22 = var24; +varonce21 = var22; +} +((struct instance_standard__NativeArray*)var12)->values[4]=var22; +} else { +var12 = varonce11; +varonce11 = NULL; +} { { /* Inline model#MClassType#mclass (var_ret) on */ -var20 = var_ret->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ -if (unlikely(var20 == NULL)) { +var27 = var_ret->attrs[COLOR_nit__model__MClassType___mclass].val; /* _mclass on */ +if (unlikely(var27 == NULL)) { PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass"); -PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1058); -show_backtrace(1); +PRINT_ERROR(" (%s:%d)\n", FILE_nit__model, 1138); +fatal_exit(1); } -var18 = var20; -RET_LABEL19:(void)0; +var25 = var27; +RET_LABEL26:(void)0; } } { -var21 = nit___nit__MClass___nit__model_base__MEntity__c_name(var18); -} -if (varonce22) { -var23 = varonce22; -} else { -var24 = "("; -var25 = 1; -var26 = standard___standard__NativeString___to_s_with_length(var24, var25); -var23 = var26; -varonce22 = var23; +var28 = nit___nit__MClass___nit__model_base__MEntity__c_name(var25); } -var27 = 1; +((struct instance_standard__NativeArray*)var12)->values[1]=var28; { -var28 = standard___standard__Array___standard__abstract_collection__SequenceRead___91d_93d(var_arguments, var27); +var29 = standard___standard__Array___standard__abstract_collection__SequenceRead___91d_93d(var_arguments, 1l); } -if (varonce29) { -var30 = varonce29; -} else { -var31 = ")"; -var32 = 1; -var33 = standard___standard__NativeString___to_s_with_length(var31, var32); -var30 = var33; -varonce29 = var30; -} -var34 = NEW_standard__Array(&type_standard__Array__standard__Object); -{ /* var34 = array_instance Array[Object] */ -var35 = 5; -var36 = NEW_standard__NativeArray(var35, &type_standard__NativeArray__standard__Object); -((struct instance_standard__NativeArray*)var36)->values[0] = (val*) var14; -((struct instance_standard__NativeArray*)var36)->values[1] = (val*) var21; -((struct instance_standard__NativeArray*)var36)->values[2] = (val*) var23; -((struct instance_standard__NativeArray*)var36)->values[3] = (val*) var28; -((struct instance_standard__NativeArray*)var36)->values[4] = (val*) var30; { -((void (*)(val* self, val* p0, long p1))(var34->class->vft[COLOR_standard__array__Array__with_native]))(var34, var36, var35) /* with_native on */; -} +var30 = ((val*(*)(val* self))(var29->class->vft[COLOR_standard__string__Object__to_s]))(var29); /* to_s on */ } +((struct instance_standard__NativeArray*)var12)->values[3]=var30; { -var37 = ((val* (*)(val* self))(var34->class->vft[COLOR_standard__string__Object__to_s]))(var34) /* to_s on */; +var31 = ((val*(*)(val* self))(var12->class->vft[COLOR_standard__string__NativeArray__native_to_s]))(var12); /* native_to_s on */ } +varonce11 = var12; { -var38 = nit___nit__AbstractCompilerVisitor___new_expr(self, var37, var_ret_type); +var32 = nit___nit__AbstractCompilerVisitor___new_expr(self, var31, var_ret_type); } { -nit___nit__AbstractCompilerVisitor___ret(self, var38); /* Direct call abstract_compiler#AbstractCompilerVisitor#ret on */ +nit___nit__AbstractCompilerVisitor___ret(self, var32); /* Direct call abstract_compiler#AbstractCompilerVisitor#ret on */ } RET_LABEL:; }