xs-src/MouseTypeConstraints.xs

   1 /*
   2  *   full definition of built-in type constraints (ware in Moose::Util::TypeConstraints::OptimizedConstraints)
   3  */
   4
   5 #include "mouse.h"
   6
   7 #if PERL_BCDVERSION >= 0x5008005
   8 #define LooksLikeNumber(sv) looks_like_number(sv)
   9 #else
  10 #define LooksLikeNumber(sv) ( SvPOKp(sv) ? looks_like_number(sv) : SvNIOKp(sv) )
  11 #endif
  12
  13 #ifndef SvRXOK
  14 #define SvRXOK(sv) (SvROK(sv) && SvMAGICAL(SvRV(sv)) && mg_find(SvRV(sv), PERL_MAGIC_qr))
  15 #endif
  16
  17 typedef int (*check_fptr_t)(pTHX_ SV* const data, SV* const sv);
  18
  19 int
  20 mouse_tc_check(pTHX_ SV* const tc_code, SV* const sv) {
  21     CV* const cv = (CV*)SvRV(tc_code);
  22     assert(SvTYPE(cv) == SVt_PVCV);
  23
  24     if(CvXSUB(cv) == XS_Mouse__Util__TypeConstraints_Item){ /* built-in */
  25         assert(CvXSUBANY(cv).any_iv > 0);
  26
  27         return mouse_builtin_tc_check(aTHX_ CvXSUBANY(cv).any_iv, sv);
  28     }
  29     else if(CvXSUB(cv) == XS_Mouse_parameterized_check){ /* built-in, parameterizad */
  30         MAGIC* const mg = (MAGIC*)CvXSUBANY(cv).any_ptr;
  31
  32         assert(CvXSUBANY(cv).any_ptr != NULL);
  33
  34         /* call the check function directly, skipping call_sv() */
  35         return CALL_FPTR((check_fptr_t)mg->mg_ptr)(aTHX_ mg->mg_obj, sv);
  36     }
  37     else { /* custom */
  38         int ok;
  39         dSP;
  40
  41         ENTER;
  42         SAVETMPS;
  43
  44         PUSHMARK(SP);
  45         XPUSHs(sv);
  46         PUTBACK;
  47
  48         call_sv(tc_code, G_SCALAR);
  49
  50         SPAGAIN;
  51         ok = SvTRUEx(POPs);
  52         PUTBACK;
  53
  54         FREETMPS;
  55         LEAVE;
  56
  57         return ok;
  58     }
  59 }
  60
  61 int
  62 mouse_builtin_tc_check(pTHX_ mouse_tc const tc, SV* const sv) {
  63     switch(tc){
  64     case MOUSE_TC_ANY:        return mouse_tc_Any(aTHX_ sv);
  65     case MOUSE_TC_ITEM:       return mouse_tc_Any(aTHX_ sv);
  66     case MOUSE_TC_MAYBE:      return mouse_tc_Any(aTHX_ sv);
  67     case MOUSE_TC_UNDEF:      return mouse_tc_Undef(aTHX_ sv);
  68     case MOUSE_TC_DEFINED:    return mouse_tc_Defined(aTHX_ sv);
  69     case MOUSE_TC_BOOL:       return mouse_tc_Bool(aTHX_ sv);
  70     case MOUSE_TC_VALUE:      return mouse_tc_Value(aTHX_ sv);
  71     case MOUSE_TC_REF:        return mouse_tc_Ref(aTHX_ sv);
  72     case MOUSE_TC_STR:        return mouse_tc_Str(aTHX_ sv);
  73     case MOUSE_TC_NUM:        return mouse_tc_Num(aTHX_ sv);
  74     case MOUSE_TC_INT:        return mouse_tc_Int(aTHX_ sv);
  75     case MOUSE_TC_SCALAR_REF: return mouse_tc_ScalarRef(aTHX_ sv);
  76     case MOUSE_TC_ARRAY_REF:  return mouse_tc_ArrayRef(aTHX_ sv);
  77     case MOUSE_TC_HASH_REF:   return mouse_tc_HashRef(aTHX_ sv);
  78     case MOUSE_TC_CODE_REF:   return mouse_tc_CodeRef(aTHX_ sv);
  79     case MOUSE_TC_GLOB_REF:   return mouse_tc_GlobRef(aTHX_ sv);
  80     case MOUSE_TC_FILEHANDLE: return mouse_tc_FileHandle(aTHX_ sv);
  81     case MOUSE_TC_REGEXP_REF: return mouse_tc_RegexpRef(aTHX_ sv);
  82     case MOUSE_TC_OBJECT:     return mouse_tc_Object(aTHX_ sv);
  83     case MOUSE_TC_CLASS_NAME: return mouse_tc_ClassName(aTHX_ sv);
  84     case MOUSE_TC_ROLE_NAME:  return mouse_tc_RoleName(aTHX_ sv);
  85     default:
  86         NOOP;
  87     }
  88
  89     croak("Mouse-panic: unrecognized type constraint id: %d", (int)tc);
  90     return FALSE; /* not reached */
  91 }
  92
  93
  94 /*
  95     The following type check functions return an integer, not a bool, to keep them simple,
  96     so if you assign these return value to bool variable, you must use "expr ? TRUE : FALSE".
  97 */
  98
  99 int
 100 mouse_tc_Any(pTHX_ SV* const sv PERL_UNUSED_DECL) {
 101     assert(sv);
 102     return TRUE;
 103 }
 104
 105 int
 106 mouse_tc_Bool(pTHX_ SV* const sv) {
 107     assert(sv);
 108
 109     if(SvTRUE(sv)){
 110         if(SvIOKp(sv)){
 111             return SvIVX(sv) == 1;
 112         }
 113         else if(SvNOKp(sv)){
 114             return SvNVX(sv) == 1.0;
 115         }
 116         else if(SvPOKp(sv)){ /* "1" */
 117             return SvCUR(sv) == 1 && SvPVX(sv)[0] == '1';
 118         }
 119         else{
 120             return FALSE;
 121         }
 122     }
 123     else{
 124         /* false must be boolean */
 125         return TRUE;
 126     }
 127 }
 128
 129 int
 130 mouse_tc_Undef(pTHX_ SV* const sv) {
 131     assert(sv);
 132     return !SvOK(sv);
 133 }
 134
 135 int
 136 mouse_tc_Defined(pTHX_ SV* const sv) {
 137     assert(sv);
 138     return SvOK(sv);
 139 }
 140
 141 int
 142 mouse_tc_Value(pTHX_ SV* const sv) {
 143     assert(sv);
 144     return SvOK(sv) && !SvROK(sv);
 145 }
 146
 147 int
 148 mouse_tc_Num(pTHX_ SV* const sv) {
 149     assert(sv);
 150     return LooksLikeNumber(sv);
 151 }
 152
 153 int
 154 mouse_tc_Int(pTHX_ SV* const sv) {
 155     assert(sv);
 156     if(SvIOKp(sv)){
 157         return TRUE;
 158     }
 159     else if(SvNOKp(sv)){
 160         NV const nv = SvNVX(sv);
 161         return nv > 0 ? (nv == (NV)(UV)nv) : (nv == (NV)(IV)nv);
 162     }
 163     else if(SvPOKp(sv)){
 164         int const num_type = grok_number(SvPVX(sv), SvCUR(sv), NULL);
 165         if(num_type){
 166             return !(num_type & IS_NUMBER_NOT_INT);
 167         }
 168     }
 169     return FALSE;
 170 }
 171
 172 int
 173 mouse_tc_Str(pTHX_ SV* const sv) {
 174     assert(sv);
 175     return SvOK(sv) && !SvROK(sv) && !isGV(sv);
 176 }
 177
 178 int
 179 mouse_tc_ClassName(pTHX_ SV* const sv){
 180     assert(sv);
 181     return is_class_loaded(sv);
 182 }
 183
 184 int
 185 mouse_tc_RoleName(pTHX_ SV* const sv) {
 186     assert(sv);
 187     if(is_class_loaded(sv)){
 188         int ok;
 189         SV* meta;
 190         dSP;
 191
 192         ENTER;
 193         SAVETMPS;
 194
 195         PUSHMARK(SP);
 196         XPUSHs(sv);
 197         PUTBACK;
 198         call_pv("Mouse::Util::get_metaclass_by_name", G_SCALAR);
 199         SPAGAIN;
 200         meta = POPs;
 201         PUTBACK;
 202
 203         ok =  is_an_instance_of("Mouse::Meta::Role", meta);
 204
 205         FREETMPS;
 206         LEAVE;
 207
 208         return ok;
 209     }
 210     return FALSE;
 211 }
 212
 213 int
 214 mouse_tc_Ref(pTHX_ SV* const sv) {
 215     assert(sv);
 216     return SvROK(sv);
 217 }
 218
 219 int
 220 mouse_tc_ScalarRef(pTHX_ SV* const sv) {
 221     assert(sv);
 222     return SvROK(sv) && !SvOBJECT(SvRV(sv)) && (SvTYPE(SvRV(sv)) <= SVt_PVLV && !isGV(SvRV(sv)));
 223 }
 224
 225 int
 226 mouse_tc_ArrayRef(pTHX_ SV* const sv) {
 227     assert(sv);
 228     return SvROK(sv) && !SvOBJECT(SvRV(sv)) && SvTYPE(SvRV(sv)) == SVt_PVAV;
 229 }
 230
 231 int
 232 mouse_tc_HashRef(pTHX_ SV* const sv) {
 233     assert(sv);
 234     return SvROK(sv) && !SvOBJECT(SvRV(sv)) && SvTYPE(SvRV(sv)) == SVt_PVHV;
 235 }
 236
 237 int
 238 mouse_tc_CodeRef(pTHX_ SV* const sv) {
 239     assert(sv);
 240     return SvROK(sv)  && !SvOBJECT(SvRV(sv))&& SvTYPE(SvRV(sv)) == SVt_PVCV;
 241 }
 242
 243 int
 244 mouse_tc_RegexpRef(pTHX_ SV* const sv) {
 245     assert(sv);
 246     return SvRXOK(sv);
 247 }
 248
 249 int
 250 mouse_tc_GlobRef(pTHX_ SV* const sv) {
 251     assert(sv);
 252     return SvROK(sv) && !SvOBJECT(SvRV(sv)) && isGV(SvRV(sv));
 253 }
 254
 255 int
 256 mouse_tc_FileHandle(pTHX_ SV* const sv) {
 257     GV* gv;
 258     assert(sv);
 259
 260     /* see pp_fileno() in pp_sys.c and Scalar::Util::openhandle() */
 261
 262     gv = (GV*)(SvROK(sv) ? SvRV(sv) : sv);
 263     if(isGV(gv) || SvTYPE(gv) == SVt_PVIO){
 264         IO* const io = isGV(gv) ? GvIO(gv) : (IO*)gv;
 265
 266         if(io && ( IoIFP(io) || SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar) )){
 267             return TRUE;
 268         }
 269     }
 270
 271     return is_an_instance_of("IO::Handle", sv);
 272 }
 273
 274 int
 275 mouse_tc_Object(pTHX_ SV* const sv) {
 276     assert(sv);
 277     return SvROK(sv) && SvOBJECT(SvRV(sv)) && !SvRXOK(sv);
 278 }
 279
 280 /* Parameterized type constraints */
 281
 282 static int
 283 mouse_parameterized_ArrayRef(pTHX_ SV* const param, SV* const sv) {
 284     if(mouse_tc_ArrayRef(aTHX_ sv)){
 285         AV* const av  = (AV*)SvRV(sv);
 286         I32 const len = av_len(av) + 1;
 287         I32 i;
 288         for(i = 0; i < len; i++){
 289             SV* const value = *av_fetch(av, i, TRUE);
 290             SvGETMAGIC(value);
 291             if(!mouse_tc_check(aTHX_ param, value)){
 292                 return FALSE;
 293             }
 294         }
 295         return TRUE;
 296     }
 297     return FALSE;
 298 }
 299
 300 static int
 301 mouse_parameterized_HashRef(pTHX_ SV* const param, SV* const sv) {
 302     if(mouse_tc_HashRef(aTHX_ sv)){
 303         HV* const hv  = (HV*)SvRV(sv);
 304         HE* he;
 305
 306         hv_iterinit(hv);
 307         while((he = hv_iternext(hv))){
 308             SV* const value = hv_iterval(hv, he);
 309             SvGETMAGIC(value);
 310             if(!mouse_tc_check(aTHX_ param, value)){
 311                 return FALSE;
 312             }
 313         }
 314         return TRUE;
 315     }
 316     return FALSE;
 317 }
 318
 319 static int
 320 mouse_parameterized_Maybe(pTHX_ SV* const param, SV* const sv) {
 321     if(SvOK(sv)){
 322         return mouse_tc_check(aTHX_ param, sv);
 323     }
 324     return TRUE;
 325 }
 326
 327 static int
 328 mouse_types_union_check(pTHX_ AV* const types, SV* const sv) {
 329     I32 const len = AvFILLp(types) + 1;
 330     I32 i;
 331
 332     for(i = 0; i < len; i++){
 333         if(mouse_tc_check(aTHX_ AvARRAY(types)[i], sv)){
 334             return TRUE;
 335         }
 336     }
 337
 338     return FALSE;
 339 }
 340
 341 static int
 342 mouse_types_check(pTHX_ AV* const types, SV* const sv) {
 343     I32 const len = AvFILLp(types) + 1;
 344     I32 i;
 345
 346     ENTER;
 347     SAVE_DEFSV;
 348     DEFSV_set(sv);
 349
 350     for(i = 0; i < len; i++){
 351         if(!mouse_tc_check(aTHX_ AvARRAY(types)[i], sv)){
 352             LEAVE;
 353             return FALSE;
 354         }
 355     }
 356
 357     LEAVE;
 358
 359     return TRUE;
 360 }
 361
 362 /*
 363  *  This class_type generator is taken from Scalar::Util::Instance
 364  */
 365
 366 #define MY_CXT_KEY "Mouse::Util::TypeConstraints::_guts" XS_VERSION
 367 typedef struct sui_cxt{
 368     GV* universal_isa;
 369 } my_cxt_t;
 370 START_MY_CXT
 371
 372 #define MG_klass_stash(mg) ((HV*)(mg)->mg_obj)
 373 #define MG_klass_pv(mg)    ((mg)->mg_ptr)
 374 #define MG_klass_len(mg)   ((mg)->mg_len)
 375
 376 static const char*
 377 mouse_canonicalize_package_name(const char* name){
 378
 379     /* "::Foo" -> "Foo" */
 380     if(name[0] == ':' && name[1] == ':'){
 381         name += 2;
 382     }
 383
 384     /* "main::main::main::Foo" -> "Foo" */
 385     while(strnEQ(name, "main::", sizeof("main::")-1)){
 386         name += sizeof("main::")-1;
 387     }
 388
 389     return name;
 390 }
 391
 392 static int
 393 mouse_lookup_isa(pTHX_ HV* const instance_stash, const char* const klass_pv){
 394     AV*  const linearized_isa = mro_get_linear_isa(instance_stash);
 395     SV**       svp            = AvARRAY(linearized_isa);
 396     SV** const end            = svp + AvFILLp(linearized_isa) + 1;
 397
 398     while(svp != end){
 399         assert(SvPVX(*svp));
 400         if(strEQ(klass_pv, mouse_canonicalize_package_name(SvPVX(*svp)))){
 401             return TRUE;
 402         }
 403         svp++;
 404     }
 405     return FALSE;
 406 }
 407
 408 int
 409 mouse_is_an_instance_of(pTHX_ HV* const stash, SV* const instance){
 410     assert(stash);
 411     assert(SvTYPE(stash) == SVt_PVHV);
 412
 413     if(IsObject(instance)){
 414         dMY_CXT;
 415         HV* const instance_stash = SvSTASH(SvRV(instance));
 416         GV* const instance_isa   = gv_fetchmeth_autoload(instance_stash, "isa", sizeof("isa")-1, 0);
 417
 418         /* the instance has no own isa method */
 419         if(instance_isa == NULL || GvCV(instance_isa) == GvCV(MY_CXT.universal_isa)){
 420             return stash == instance_stash
 421                 || mouse_lookup_isa(aTHX_ instance_stash, HvNAME_get(stash));
 422         }
 423         /* the instance has its own isa method */
 424         else {
 425             int retval;
 426             dSP;
 427
 428             ENTER;
 429             SAVETMPS;
 430
 431             PUSHMARK(SP);
 432             EXTEND(SP, 2);
 433             PUSHs(instance);
 434             mPUSHp(HvNAME_get(stash), HvNAMELEN_get(stash));
 435             PUTBACK;
 436
 437             call_sv((SV*)instance_isa, G_SCALAR);
 438
 439             SPAGAIN;
 440
 441             retval = SvTRUEx(POPs);
 442
 443             PUTBACK;
 444
 445             FREETMPS;
 446             LEAVE;
 447
 448             return retval;
 449         }
 450     }
 451     return FALSE;
 452 }
 453
 454 static int
 455 mouse_is_an_instance_of_universal(pTHX_ SV* const data, SV* const sv){
 456     PERL_UNUSED_ARG(data);
 457     return SvROK(sv) && SvOBJECT(SvRV(sv));
 458 }
 459
 460 static MGVTBL mouse_util_type_constraints_vtbl; /* not used, only for identity */
 461
 462 static CV*
 463 mouse_tc_parameterize(pTHX_ const char* const name, check_fptr_t const fptr, SV* const param) {
 464     CV* xsub;
 465
 466     xsub = newXS(name, XS_Mouse_parameterized_check, __FILE__);
 467     CvXSUBANY(xsub).any_ptr = sv_magicext(
 468         (SV*)xsub,
 469         param,       /* mg_obj: refcnt will be increased */
 470         PERL_MAGIC_ext,
 471         &mouse_util_type_constraints_vtbl,
 472         (void*)fptr, /* mg_ptr */
 473         0            /* mg_len: 0 for static data */
 474     );
 475
 476     if(!name){
 477         sv_2mortal((SV*)xsub);
 478     }
 479
 480     return xsub;
 481 }
 482
 483 CV*
 484 mouse_generate_isa_predicate_for(pTHX_ SV* const klass, const char* const predicate_name){
 485     STRLEN klass_len;
 486     const char* klass_pv = SvPV_const(klass, klass_len);
 487     SV*   param;
 488     void* fptr;
 489
 490     klass_pv = mouse_canonicalize_package_name(klass_pv);
 491
 492     if(strNE(klass_pv, "UNIVERSAL")){
 493         param = (SV*)gv_stashpvn(klass_pv, klass_len, GV_ADD);
 494         fptr = (void*)mouse_is_an_instance_of;
 495
 496     }
 497     else{
 498         param = NULL;
 499         fptr = (void*)mouse_is_an_instance_of_universal;
 500     }
 501
 502     return mouse_tc_parameterize(aTHX_ predicate_name, fptr, param);
 503 }
 504
 505 XS(XS_Mouse_parameterized_check) {
 506     dVAR;
 507     dXSARGS;
 508     MAGIC* const mg = (MAGIC*)XSANY.any_ptr;
 509
 510     if(items < 1){
 511         croak("Too few arguments for parameterized check functions");
 512     }
 513
 514     SvGETMAGIC( ST(0) );
 515     ST(0) = boolSV( CALL_FPTR((check_fptr_t)mg->mg_ptr)(aTHX_ mg->mg_obj, ST(0)) );
 516     XSRETURN(1);
 517 }
 518
 519 static void
 520 setup_my_cxt(pTHX_ pMY_CXT){
 521     MY_CXT.universal_isa = gv_fetchpvs("UNIVERSAL::isa", GV_ADD, SVt_PVCV);
 522     SvREFCNT_inc_simple_void_NN(MY_CXT.universal_isa);
 523 }
 524
 525 MODULE = Mouse::Util::TypeConstraints    PACKAGE = Mouse::Util::TypeConstraints
 526
 527 PROTOTYPES:   DISABLE
 528 VERSIONCHECK: DISABLE
 529
 530 BOOT:
 531 {
 532     MY_CXT_INIT;
 533     setup_my_cxt(aTHX_ aMY_CXT);
 534 }
 535
 536 #ifdef USE_ITHREADS
 537
 538 void
 539 CLONE(...)
 540 CODE:
 541 {
 542     MY_CXT_CLONE;
 543     setup_my_cxt(aTHX_ aMY_CXT);
 544     PERL_UNUSED_VAR(items);
 545 }
 546
 547 #endif /* !USE_ITHREADS */
 548
 549 void
 550 Item(SV* sv = &PL_sv_undef)
 551 ALIAS:
 552     Any        = MOUSE_TC_ANY
 553     Item       = MOUSE_TC_ITEM
 554     Undef      = MOUSE_TC_UNDEF
 555     Defined    = MOUSE_TC_DEFINED
 556     Bool       = MOUSE_TC_BOOL
 557     Value      = MOUSE_TC_VALUE
 558     Ref        = MOUSE_TC_REF
 559     Str        = MOUSE_TC_STR
 560     Num        = MOUSE_TC_NUM
 561     Int        = MOUSE_TC_INT
 562     ScalarRef  = MOUSE_TC_SCALAR_REF
 563     ArrayRef   = MOUSE_TC_ARRAY_REF
 564     HashRef    = MOUSE_TC_HASH_REF
 565     CodeRef    = MOUSE_TC_CODE_REF
 566     GlobRef    = MOUSE_TC_GLOB_REF
 567     FileHandle = MOUSE_TC_FILEHANDLE
 568     RegexpRef  = MOUSE_TC_REGEXP_REF
 569     Object     = MOUSE_TC_OBJECT
 570     ClassName  = MOUSE_TC_CLASS_NAME
 571     RoleName   = MOUSE_TC_ROLE_NAME
 572 CODE:
 573     SvGETMAGIC(sv);
 574     ST(0) = boolSV( mouse_builtin_tc_check(aTHX_ ix, sv) );
 575     XSRETURN(1);
 576
 577
 578 CV*
 579 _parameterize_ArrayRef_for(SV* param)
 580 ALIAS:
 581     _parameterize_ArrayRef_for = MOUSE_TC_ARRAY_REF
 582     _parameterize_HashRef_for  = MOUSE_TC_HASH_REF
 583     _parameterize_Maybe_for    = MOUSE_TC_MAYBE
 584 CODE:
 585 {
 586     check_fptr_t fptr;
 587     SV* const tc_code = mcall0s(param, "_compiled_type_constraint");
 588     if(!(SvROK(tc_code) && SvTYPE(SvRV(tc_code)) == SVt_PVCV)){
 589         croak("_compiled_type_constraint didn't return a CODE reference");
 590     }
 591
 592     switch(ix){
 593     case MOUSE_TC_ARRAY_REF:
 594         fptr = mouse_parameterized_ArrayRef;
 595         break;
 596     case MOUSE_TC_HASH_REF:
 597         fptr = mouse_parameterized_HashRef;
 598         break;
 599     default: /* Maybe type */
 600         fptr = mouse_parameterized_Maybe;
 601     }
 602     RETVAL = mouse_tc_parameterize(aTHX_ NULL, fptr, tc_code);
 603 }
 604 OUTPUT:
 605     RETVAL
 606
 607 MODULE = Mouse::Util::TypeConstraints    PACKAGE = Mouse::Meta::TypeConstraint
 608
 609 void
 610 compile_type_constraint(SV* self)
 611 CODE:
 612 {
 613     AV* const checks = newAV();
 614     SV* check; /* check function */
 615     SV* parent;
 616     SV* types_ref;
 617
 618     sv_2mortal((SV*)checks);
 619
 620     for(parent = get_slots(self, "parent"); parent; parent = get_slots(parent, "parent")){
 621         check = get_slots(parent, "hand_optimized_type_constraint");
 622         if(check && SvOK(check)){
 623             if(!mouse_tc_CodeRef(aTHX_ check)){
 624                 croak("Not a CODE reference");
 625             }
 626             av_unshift(checks, 1);
 627             av_store(checks, 0, newSVsv(check));
 628             break; /* a hand optimized constraint must include all the parent */
 629         }
 630
 631         check = get_slots(parent, "constraint");
 632         if(check && SvOK(check)){
 633             if(!mouse_tc_CodeRef(aTHX_ check)){
 634                 croak("Not a CODE reference");
 635             }
 636             av_unshift(checks, 1);
 637             av_store(checks, 0, newSVsv(check));
 638         }
 639     }
 640
 641     check = get_slots(self, "constraint");
 642     if(check && SvOK(check)){
 643         if(!mouse_tc_CodeRef(aTHX_ check)){
 644             croak("Not a CODE reference");
 645         }
 646         av_push(checks, newSVsv(check));
 647     }
 648
 649     types_ref = get_slots(self, "type_constraints");
 650     if(types_ref && SvOK(types_ref)){ /* union type */
 651         AV* types;
 652         AV* union_checks;
 653         CV* union_check;
 654         I32 len;
 655         I32 i;
 656
 657         if(!mouse_tc_ArrayRef(aTHX_ types_ref)){
 658             croak("Not an ARRAY reference");
 659         }
 660         types = (AV*)SvRV(types_ref);
 661         len = av_len(types) + 1;
 662
 663         union_checks = newAV();
 664         sv_2mortal((SV*)union_checks);
 665
 666         for(i = 0; i < len; i++){
 667             SV* const tc = *av_fetch(types, i, TRUE);
 668             SV* const c  = get_slots(tc, "compiled_type_constraint");
 669             if(!(c && mouse_tc_CodeRef(aTHX_ c))){
 670                 sv_dump(self);
 671                 croak("'%"SVf"' has no compiled type constraint", self);
 672             }
 673             av_push(union_checks, newSVsv(c));
 674         }
 675
 676         union_check = mouse_tc_parameterize(aTHX_ NULL, (check_fptr_t)mouse_types_union_check, (SV*)union_checks);
 677         av_push(checks, newRV_inc((SV*)union_check));
 678     }
 679
 680     if(AvFILLp(checks) < 0){
 681         check = newRV_inc((SV*)get_cv("Mouse::Util::TypeConstraints::Any", TRUE));
 682     }
 683     else{
 684         check = newRV_inc((SV*)mouse_tc_parameterize(aTHX_ NULL, (check_fptr_t)mouse_types_check, (SV*)checks));
 685     }
 686     set_slots(self, "compiled_type_constraint", check);
 687 }
 688