fix for prototype undecl issue when type constraint utils loaded before consumers...

[gitmo/Moose.git] / lib / Moose / Util / TypeConstraints.pm

diff --git a/lib/Moose/Util/TypeConstraints.pm b/lib/Moose/Util/TypeConstraints.pm
index 583861f..d984085 100644 (file)
--- a/lib/Moose/Util/TypeConstraints.pm
+++ b/lib/Moose/Util/TypeConstraints.pm
@@ -12,6 +12,26 @@ use Sub::Exporter;
 our $VERSION   = '0.12';
 our $AUTHORITY = 'cpan:STEVAN';
 
+# Prototyped subs must be predeclared because we have a circular dependency
+# with Moose::Meta::Attribute et. al. so in case of us being use'd first the
+# predeclaration ensures the prototypes are in scope when consumers are
+# compiled
+
+sub find_type_constraint ($);
+sub _create_type_constraint ($$$;$$);
+sub _install_type_coercions ($$);
+sub create_type_constraint_union (@);
+sub type ($$;$$);
+sub subtype ($$;$$$);
+sub coerce ($@);
+sub as      ($);
+sub from    ($);
+sub where   (&);
+sub via     (&);
+sub message     (&);
+sub optimize_as (&);
+sub enum ($;@);
+
 use Moose::Meta::TypeConstraint;
 use Moose::Meta::TypeCoercion;
 
@@ -71,10 +91,14 @@ sub unimport {
             $optimized = $_->{optimized} if exists $_->{optimized};            
         }
 
-        my $pkg_defined_in = scalar(caller(1));
+        my $pkg_defined_in = scalar(caller(0));
+        
         ($TYPES{$name}->[0] eq $pkg_defined_in)
-            || confess "The type constraint '$name' has already been created "
-                 if defined $name && exists $TYPES{$name};                
+            || confess ("The type constraint '$name' has already been created in " 
+                       . $TYPES{$name}->[0] . " and cannot be created again in "
+                       . $pkg_defined_in)
+                 if defined $name && exists $TYPES{$name};   
+                              
         $parent = find_type_constraint($parent) if defined $parent;
         my $constraint = Moose::Meta::TypeConstraint->new(
             name       => $name || '__ANON__',
@@ -108,13 +132,15 @@ sub unimport {
         );
     }
     
-    sub export_type_contstraints_as_functions {
+    sub export_type_constraints_as_functions {
         my $pkg = caller();
            no strict 'refs';
        foreach my $constraint (keys %TYPES) {
                *{"${pkg}::${constraint}"} = find_type_constraint($constraint)->_compiled_type_constraint;
        }        
-    } 
+    }
+    
+    *Moose::Util::TypeConstraints::export_type_contstraints_as_functions = \&export_type_constraints_as_functions;
     
     sub list_all_type_constraints { keys %TYPES }   
 }
@@ -374,12 +400,16 @@ meta-object. What you do with it from there is up to you :)
 Given a list of C<@type_constraint_names>, this will return a 
 B<Moose::Meta::TypeConstraint::Union> instance.
 
-=item B<export_type_contstraints_as_functions>
+=item B<export_type_constraints_as_functions>
 
 This will export all the current type constraints as functions 
 into the caller's namespace. Right now, this is mostly used for 
 testing, but it might prove useful to others.
 
+=item B<export_type_contstraints_as_functions>
+
+Alias for the above function.
+
 =item B<list_all_type_constraints>
 
 This will return a list of type constraint names, you can then 
@@ -400,7 +430,7 @@ The following functions are used to create type constraints.
 They will then register the type constraints in a global store 
 where Moose can get to them if it needs to. 
 
-See the L<SYNOPOSIS> for an example of how to use these.
+See the L<SYNOPSIS> for an example of how to use these.
 
 =over 4
 
@@ -460,7 +490,7 @@ code first, followed by the type constraint check. This feature
 should be used carefully as it is very powerful and could easily 
 take off a limb if you are not careful.
 
-See the L<SYNOPOSIS> for an example of how to use these.
+See the L<SYNOPSIS> for an example of how to use these.
 
 =over 4