2 package Moose::Meta::Class;
9 use Carp qw( confess );
11 use List::Util qw( first );
12 use List::MoreUtils qw( any all uniq first_index );
13 use Scalar::Util 'blessed';
15 use Moose::Meta::Method::Overridden;
16 use Moose::Meta::Method::Augmented;
17 use Moose::Error::Default;
18 use Moose::Meta::Class::Immutable::Trait;
19 use Moose::Meta::Method::Constructor;
20 use Moose::Meta::Method::Destructor;
21 use Moose::Meta::Method::Meta;
23 use Class::MOP::MiniTrait;
25 use base 'Class::MOP::Class';
27 Class::MOP::MiniTrait::apply(__PACKAGE__, 'Moose::Meta::Object::Trait');
29 __PACKAGE__->meta->add_attribute('roles' => (
31 default => sub { [] },
32 Class::MOP::_definition_context(),
35 __PACKAGE__->meta->add_attribute('role_applications' => (
36 reader => '_get_role_applications',
37 default => sub { [] },
38 Class::MOP::_definition_context(),
41 __PACKAGE__->meta->add_attribute(
42 Class::MOP::Attribute->new('immutable_trait' => (
43 accessor => "immutable_trait",
44 default => 'Moose::Meta::Class::Immutable::Trait',
45 Class::MOP::_definition_context(),
49 __PACKAGE__->meta->add_attribute('constructor_class' => (
50 accessor => 'constructor_class',
51 default => 'Moose::Meta::Method::Constructor',
52 Class::MOP::_definition_context(),
55 __PACKAGE__->meta->add_attribute('destructor_class' => (
56 accessor => 'destructor_class',
57 default => 'Moose::Meta::Method::Destructor',
58 Class::MOP::_definition_context(),
61 __PACKAGE__->meta->add_attribute('error_class' => (
62 accessor => 'error_class',
63 default => 'Moose::Error::Default',
64 Class::MOP::_definition_context(),
70 unshift @args, 'package' if @args % 2;
72 my $package = delete $opts{package};
73 return Class::MOP::get_metaclass_by_name($package)
74 || $class->SUPER::initialize($package,
75 'attribute_metaclass' => 'Moose::Meta::Attribute',
76 'method_metaclass' => 'Moose::Meta::Method',
77 'instance_metaclass' => 'Moose::Meta::Instance',
86 unshift @args, 'package' if @args % 2 == 1;
89 (ref $options{roles} eq 'ARRAY')
90 || $class->throw_error("You must pass an ARRAY ref of roles", data => $options{roles})
91 if exists $options{roles};
93 my $package = delete $options{package};
94 my $roles = delete $options{roles};
96 my $new_meta = $class->SUPER::create($package, %options);
99 Moose::Util::apply_all_roles( $new_meta, @$roles );
105 sub _meta_method_class { 'Moose::Meta::Method::Meta' }
107 sub _anon_package_prefix { 'Moose::Meta::Class::__ANON__::SERIAL::' }
109 sub _anon_cache_key {
113 my $superclass_key = join('|',
114 map { $_->[0] } @{ Data::OptList::mkopt($options{superclasses} || []) }
117 my $roles = Data::OptList::mkopt(($options{roles} || []), {
119 val_test => sub { ref($_[0]) eq 'HASH' },
123 for my $role_spec (@$roles) {
124 my ($role, $params) = @$role_spec;
125 $params = { %$params } if $params;
127 my $key = blessed($role) ? $role->name : $role;
129 if ($params && %$params) {
130 my $alias = delete $params->{'-alias'}
131 || delete $params->{'alias'}
133 my $excludes = delete $params->{'-excludes'}
134 || delete $params->{'excludes'}
136 $excludes = [$excludes] unless ref($excludes) eq 'ARRAY';
139 warn "Roles with parameters cannot be cached. Consider "
140 . "applying the parameters before calling "
141 . "create_anon_class, or using 'weaken => 0' instead";
145 my $alias_key = join('%',
146 map { $_ => $alias->{$_} } sort keys %$alias
148 my $excludes_key = join('%',
151 $key .= '<' . join('+', 'a', $alias_key, 'e', $excludes_key) . '>';
154 push @role_keys, $key;
157 my $role_key = join('|', sort @role_keys);
159 # Makes something like Super::Class|Super::Class::2=Role|Role::1
160 return join('=', $superclass_key, $role_key);
167 my $meta = blessed $pkg ? $pkg : Class::MOP::class_of($pkg);
169 my %existing_classes;
171 %existing_classes = map { $_ => $meta->$_() } qw(
174 wrapped_method_metaclass
182 return $self->SUPER::reinitialize(
190 my ($self, $role) = @_;
191 (blessed($role) && $role->isa('Moose::Meta::Role'))
192 || $self->throw_error("Roles must be instances of Moose::Meta::Role", data => $role);
193 push @{$self->roles} => $role;
196 sub role_applications {
199 return @{$self->_get_role_applications};
202 sub add_role_application {
203 my ($self, $application) = @_;
204 (blessed($application) && $application->isa('Moose::Meta::Role::Application::ToClass'))
205 || $self->throw_error("Role applications must be instances of Moose::Meta::Role::Application::ToClass", data => $application);
206 push @{$self->_get_role_applications} => $application;
209 sub calculate_all_roles {
212 grep { !$seen{$_->name}++ } map { $_->calculate_all_roles } @{ $self->roles };
215 sub calculate_all_roles_with_inheritance {
218 grep { !$seen{$_->name}++ }
219 map { Class::MOP::class_of($_)->can('calculate_all_roles')
220 ? Class::MOP::class_of($_)->calculate_all_roles
222 $self->linearized_isa;
226 my ($self, $role_name) = @_;
229 || $self->throw_error("You must supply a role name to look for");
231 foreach my $class ($self->class_precedence_list) {
232 my $meta = Class::MOP::class_of($class);
233 # when a Moose metaclass is itself extended with a role,
234 # this check needs to be done since some items in the
235 # class_precedence_list might in fact be Class::MOP
237 next unless $meta && $meta->can('roles');
238 foreach my $role (@{$meta->roles}) {
239 return 1 if $role->does_role($role_name);
246 my ($self, $role_name) = @_;
249 || $self->throw_error("You must supply a role name to look for");
251 foreach my $class ($self->class_precedence_list) {
252 my $meta = Class::MOP::class_of($class);
253 # when a Moose metaclass is itself extended with a role,
254 # this check needs to be done since some items in the
255 # class_precedence_list might in fact be Class::MOP
257 next unless $meta && $meta->can('roles');
258 foreach my $role (@{$meta->roles}) {
259 return 1 if $role->excludes_role($role_name);
267 my $params = @_ == 1 ? $_[0] : {@_};
268 my $object = $self->SUPER::new_object($params);
270 $self->call_all_triggers($object, $params);
272 $object->BUILDALL($params) if $object->can('BUILDALL');
277 sub call_all_triggers {
278 my ($self, $object, $params) = @_;
280 foreach my $attr ($self->get_all_attributes()) {
282 next unless $attr->can('has_trigger') && $attr->has_trigger;
284 my $init_arg = $attr->init_arg;
285 next unless defined $init_arg;
286 next unless exists $params->{$init_arg};
292 ? $attr->get_read_method_ref->($object)
293 : $params->{$init_arg}
299 sub _generate_fallback_constructor {
302 return $class . '->Moose::Object::new(@_)'
307 my ($params, $class) = @_;
309 'my ' . $params . ' = ',
310 $self->_inline_BUILDARGS($class, '@_'),
315 sub _inline_BUILDARGS {
317 my ($class, $args) = @_;
319 my $buildargs = $self->find_method_by_name("BUILDARGS");
322 && (!$buildargs or $buildargs->body == \&Moose::Object::BUILDARGS)) {
326 'if (scalar @_ == 1) {',
327 'if (!defined($_[0]) || ref($_[0]) ne \'HASH\') {',
328 $self->_inline_throw_error(
329 '"Single parameters to new() must be a HASH ref"',
333 '$params = { %{ $_[0] } };',
337 '"The new() method for ' . $class . ' expects a '
338 . 'hash reference or a key/value list. You passed an '
339 . 'odd number of arguments"',
341 '$params = {@_, undef};',
351 return $class . '->BUILDARGS(' . $args . ')';
355 sub _inline_slot_initializer {
357 my ($attr, $idx) = @_;
361 $self->_inline_check_required_attr($attr),
362 $self->SUPER::_inline_slot_initializer(@_),
366 sub _inline_check_required_attr {
370 return unless defined $attr->init_arg;
371 return unless $attr->can('is_required') && $attr->is_required;
372 return if $attr->has_default || $attr->has_builder;
375 'if (!exists $params->{\'' . $attr->init_arg . '\'}) {',
376 $self->_inline_throw_error(
377 '"Attribute (' . quotemeta($attr->name) . ') is required"'
383 # XXX: these two are duplicated from cmop, because we have to pass the tc stuff
384 # through to _inline_set_value - this should probably be fixed, but i'm not
385 # quite sure how. -doy
386 sub _inline_init_attr_from_constructor {
388 my ($attr, $idx) = @_;
390 my @initial_value = $attr->_inline_set_value(
392 '$params->{\'' . $attr->init_arg . '\'}',
393 '$type_constraint_bodies[' . $idx . ']',
394 '$type_coercions[' . $idx . ']',
395 '$type_constraint_messages[' . $idx . ']',
399 push @initial_value, (
400 '$attrs->[' . $idx . ']->set_initial_value(',
402 $attr->_inline_instance_get('$instance'),
404 ) if $attr->has_initializer;
406 return @initial_value;
409 sub _inline_init_attr_from_default {
411 my ($attr, $idx) = @_;
413 return if $attr->can('is_lazy') && $attr->is_lazy;
414 my $default = $self->_inline_default_value($attr, $idx);
415 return unless $default;
417 my @initial_value = (
418 'my $default = ' . $default . ';',
419 $attr->_inline_set_value(
422 '$type_constraint_bodies[' . $idx . ']',
423 '$type_coercions[' . $idx . ']',
424 '$type_constraint_messages[' . $idx . ']',
429 push @initial_value, (
430 '$attrs->[' . $idx . ']->set_initial_value(',
432 $attr->_inline_instance_get('$instance'),
434 ) if $attr->has_initializer;
436 return @initial_value;
439 sub _inline_extra_init {
442 $self->_inline_triggers,
443 $self->_inline_BUILDALL,
447 sub _inline_triggers {
451 my @attrs = sort { $a->name cmp $b->name } $self->get_all_attributes;
452 for my $i (0 .. $#attrs) {
453 my $attr = $attrs[$i];
455 next unless $attr->can('has_trigger') && $attr->has_trigger;
457 my $init_arg = $attr->init_arg;
458 next unless defined $init_arg;
461 'if (exists $params->{\'' . $init_arg . '\'}) {',
462 '$triggers->[' . $i . ']->(',
464 $attr->_inline_instance_get('$instance') . ',',
469 return @trigger_calls;
472 sub _inline_BUILDALL {
475 my @methods = reverse $self->find_all_methods_by_name('BUILD');
478 foreach my $method (@methods) {
480 '$instance->' . $method->{class} . '::BUILD($params);';
486 sub _eval_environment {
489 my @attrs = sort { $a->name cmp $b->name } $self->get_all_attributes;
492 map { $_->can('has_trigger') && $_->has_trigger ? $_->trigger : undef }
496 # We need to check if the attribute ->can('type_constraint')
497 # since we may be trying to immutabilize a Moose meta class,
498 # which in turn has attributes which are Class::MOP::Attribute
499 # objects, rather than Moose::Meta::Attribute. And
500 # Class::MOP::Attribute attributes have no type constraints.
501 # However we need to make sure we leave an undef value there
502 # because the inlined code is using the index of the attributes
503 # to determine where to find the type constraint
505 my @type_constraints = map {
506 $_->can('type_constraint') ? $_->type_constraint : undef
509 my @type_constraint_bodies = map {
510 defined $_ ? $_->_compiled_type_constraint : undef;
513 my @type_coercions = map {
514 defined $_ && $_->has_coercion
515 ? $_->coercion->_compiled_type_coercion
519 my @type_constraint_messages = map {
521 ? ($_->has_message ? $_->message : $_->_default_message)
526 %{ $self->SUPER::_eval_environment },
527 ((any { defined && $_->has_initializer } @attrs)
528 ? ('$attrs' => \[@attrs])
530 '$triggers' => \$triggers,
531 '@type_coercions' => \@type_coercions,
532 '@type_constraint_bodies' => \@type_constraint_bodies,
533 '@type_constraint_messages' => \@type_constraint_messages,
534 ( map { defined($_) ? %{ $_->inline_environment } : () }
536 # pretty sure this is only going to be closed over if you use a custom
537 # error class at this point, but we should still get rid of this
545 my $supers = Data::OptList::mkopt(\@_);
546 foreach my $super (@{ $supers }) {
547 my ($name, $opts) = @{ $super };
548 Class::MOP::load_class($name, $opts);
549 my $meta = Class::MOP::class_of($name);
550 $self->throw_error("You cannot inherit from a Moose Role ($name)")
551 if $meta && $meta->isa('Moose::Meta::Role')
553 return $self->SUPER::superclasses(map { $_->[0] } @{ $supers });
556 ### ---------------------------------------------
561 (blessed $_[0] && $_[0]->isa('Class::MOP::Attribute')
563 : $self->_process_attribute(@_));
564 $self->SUPER::add_attribute($attr);
565 # it may be a Class::MOP::Attribute, theoretically, which doesn't have
566 # 'bare' and doesn't implement this method
567 if ($attr->can('_check_associated_methods')) {
568 $attr->_check_associated_methods;
573 sub add_override_method_modifier {
574 my ($self, $name, $method, $_super_package) = @_;
576 (!$self->has_method($name))
577 || $self->throw_error("Cannot add an override method if a local method is already present");
579 $self->add_method($name => Moose::Meta::Method::Overridden->new(
582 package => $_super_package, # need this for roles
587 sub add_augment_method_modifier {
588 my ($self, $name, $method) = @_;
589 (!$self->has_method($name))
590 || $self->throw_error("Cannot add an augment method if a local method is already present");
592 $self->add_method($name => Moose::Meta::Method::Augmented->new(
599 ## Private Utility methods ...
601 sub _find_next_method_by_name_which_is_not_overridden {
602 my ($self, $name) = @_;
603 foreach my $method ($self->find_all_methods_by_name($name)) {
604 return $method->{code}
605 if blessed($method->{code}) && !$method->{code}->isa('Moose::Meta::Method::Overridden');
610 ## Metaclass compatibility
612 sub _base_metaclasses {
614 my %metaclasses = $self->SUPER::_base_metaclasses;
615 for my $class (keys %metaclasses) {
616 $metaclasses{$class} =~ s/^Class::MOP/Moose::Meta/;
620 error_class => 'Moose::Error::Default',
624 sub _fix_class_metaclass_incompatibility {
626 my ($super_meta) = @_;
628 $self->SUPER::_fix_class_metaclass_incompatibility(@_);
630 if ($self->_class_metaclass_can_be_made_compatible($super_meta)) {
632 || confess "Can't fix metaclass incompatibility for "
634 . " because it is not pristine.";
635 my $super_meta_name = $super_meta->_real_ref_name;
636 my $class_meta_subclass_meta_name = Moose::Util::_reconcile_roles_for_metaclass(blessed($self), $super_meta_name);
637 my $new_self = $class_meta_subclass_meta_name->reinitialize(
641 $self->_replace_self( $new_self, $class_meta_subclass_meta_name );
645 sub _fix_single_metaclass_incompatibility {
647 my ($metaclass_type, $super_meta) = @_;
649 $self->SUPER::_fix_single_metaclass_incompatibility(@_);
651 if ($self->_single_metaclass_can_be_made_compatible($super_meta, $metaclass_type)) {
653 || confess "Can't fix metaclass incompatibility for "
655 . " because it is not pristine.";
656 my $super_meta_name = $super_meta->_real_ref_name;
657 my $class_specific_meta_subclass_meta_name = Moose::Util::_reconcile_roles_for_metaclass($self->$metaclass_type, $super_meta->$metaclass_type);
658 my $new_self = $super_meta->reinitialize(
660 $metaclass_type => $class_specific_meta_subclass_meta_name,
663 $self->_replace_self( $new_self, $super_meta_name );
669 my ( $new_self, $new_class) = @_;
672 bless $self, $new_class;
674 # We need to replace the cached metaclass instance or else when it goes
675 # out of scope Class::MOP::Class destroy's the namespace for the
676 # metaclass's class, causing much havoc.
677 my $weaken = Class::MOP::metaclass_is_weak( $self->name );
678 Class::MOP::store_metaclass_by_name( $self->name, $self );
679 Class::MOP::weaken_metaclass( $self->name ) if $weaken;
682 sub _process_attribute {
683 my ( $self, $name, @args ) = @_;
685 @args = %{$args[0]} if scalar @args == 1 && ref($args[0]) eq 'HASH';
687 if (($name || '') =~ /^\+(.*)/) {
688 return $self->_process_inherited_attribute($1, @args);
691 return $self->_process_new_attribute($name, @args);
695 sub _process_new_attribute {
696 my ( $self, $name, @args ) = @_;
698 $self->attribute_metaclass->interpolate_class_and_new($name, @args);
701 sub _process_inherited_attribute {
702 my ($self, $attr_name, %options) = @_;
703 my $inherited_attr = $self->find_attribute_by_name($attr_name);
704 (defined $inherited_attr)
705 || $self->throw_error("Could not find an attribute by the name of '$attr_name' to inherit from in ${\$self->name}", data => $attr_name);
706 if ($inherited_attr->isa('Moose::Meta::Attribute')) {
707 return $inherited_attr->clone_and_inherit_options(%options);
711 # kind of a kludge to handle Class::MOP::Attributes
712 return $inherited_attr->Moose::Meta::Attribute::clone_and_inherit_options(%options);
716 # reinitialization support
718 sub _restore_metaobjects_from {
722 $self->SUPER::_restore_metaobjects_from($old_meta);
724 for my $role ( @{ $old_meta->roles } ) {
725 $self->add_role($role);
728 for my $application ( @{ $old_meta->_get_role_applications } ) {
729 $application->class($self);
730 $self->add_role_application ($application);
736 sub _immutable_options {
737 my ( $self, @args ) = @_;
739 $self->SUPER::_immutable_options(
740 inline_destructor => 1,
742 # Moose always does this when an attribute is created
743 inline_accessors => 0,
750 sub _fixup_attributes_after_rebless {
752 my ($instance, $rebless_from, %params) = @_;
754 $self->SUPER::_fixup_attributes_after_rebless($instance, $rebless_from, %params);
756 $self->call_all_triggers($instance, \%params);
761 ## -------------------------------------------------
766 my ( $self, @args ) = @_;
767 local $error_level = ($error_level || 0) + 1;
768 $self->raise_error($self->create_error(@args));
771 sub _inline_throw_error {
772 my ( $self, @args ) = @_;
773 $self->_inline_raise_error($self->_inline_create_error(@args));
777 my ( $self, @args ) = @_;
781 sub _inline_raise_error {
782 my ( $self, $message ) = @_;
784 return 'die ' . $message;
788 my ( $self, @args ) = @_;
792 local $error_level = ($error_level || 0 ) + 1;
794 if ( @args % 2 == 1 ) {
795 unshift @args, "message";
798 my %args = ( metaclass => $self, last_error => $@, @args );
800 $args{depth} += $error_level;
802 my $class = ref $self ? $self->error_class : "Moose::Error::Default";
804 Class::MOP::load_class($class);
807 Carp::caller_info($args{depth}),
812 sub _inline_create_error {
813 my ( $self, $msg, $args ) = @_;
814 # XXX ignore $args for now, nothing currently uses it anyway
824 my $class = ref $self ? $self->error_class : "Moose::Error::Default";
826 Class::MOP::load_class($class);
828 # don't check inheritance here - the intention is that the class needs
829 # to provide a non-inherited inlining method, because falling back to
830 # the default inlining method is most likely going to be wrong
831 # yes, this is a huge hack, but so is the entire error system, so.
832 return '$meta->create_error(' . $msg . ', ' . $args . ');'
833 unless $class->meta->has_method('_inline_new');
836 # XXX ignore this for now too
837 # Carp::caller_info($args{depth}),
844 # ABSTRACT: The Moose metaclass
852 This class is a subclass of L<Class::MOP::Class> that provides
853 additional Moose-specific functionality.
855 To really understand this class, you will need to start with the
856 L<Class::MOP::Class> documentation. This class can be understood as a
857 set of additional features on top of the basic feature provided by
862 C<Moose::Meta::Class> is a subclass of L<Class::MOP::Class>.
868 =item B<< Moose::Meta::Class->initialize($package_name, %options) >>
870 This overrides the parent's method in order to provide its own
871 defaults for the C<attribute_metaclass>, C<instance_metaclass>, and
872 C<method_metaclass> options.
874 These all default to the appropriate Moose class.
876 =item B<< Moose::Meta::Class->create($package_name, %options) >>
878 This overrides the parent's method in order to accept a C<roles>
879 option. This should be an array reference containing roles
880 that the class does, each optionally followed by a hashref of options
881 (C<-excludes> and C<-alias>).
883 my $metaclass = Moose::Meta::Class->create( 'New::Class', roles => [...] );
885 =item B<< Moose::Meta::Class->create_anon_class >>
887 This overrides the parent's method to accept a C<roles> option, just
890 It also accepts a C<cache> option. If this is true, then the anonymous
891 class will be cached based on its superclasses and roles. If an
892 existing anonymous class in the cache has the same superclasses and
893 roles, it will be reused.
895 my $metaclass = Moose::Meta::Class->create_anon_class(
896 superclasses => ['Foo'],
897 roles => [qw/Some Roles Go Here/],
901 Each entry in both the C<superclasses> and the C<roles> option can be
902 followed by a hash reference with arguments. The C<superclasses>
903 option can be supplied with a L<-version|Class::MOP/Class Loading
904 Options> option that ensures the loaded superclass satisfies the
905 required version. The C<role> option also takes the C<-version> as an
906 argument, but the option hash reference can also contain any other
907 role relevant values like exclusions or parameterized role arguments.
909 =item B<< $metaclass->make_immutable(%options) >>
911 This overrides the parent's method to add a few options. Specifically,
912 it uses the Moose-specific constructor and destructor classes, and
913 enables inlining the destructor.
915 Since Moose always inlines attributes, it sets the C<inline_accessors> option
918 =item B<< $metaclass->new_object(%params) >>
920 This overrides the parent's method in order to add support for
923 =item B<< $metaclass->superclasses(@superclasses) >>
925 This is the accessor allowing you to read or change the parents of
928 Each superclass can be followed by a hash reference containing a
929 L<-version|Class::MOP/Class Loading Options> value. If the version
930 requirement is not satisfied an error will be thrown.
932 =item B<< $metaclass->add_override_method_modifier($name, $sub) >>
934 This adds an C<override> method modifier to the package.
936 =item B<< $metaclass->add_augment_method_modifier($name, $sub) >>
938 This adds an C<augment> method modifier to the package.
940 =item B<< $metaclass->calculate_all_roles >>
942 This will return a unique array of C<Moose::Meta::Role> instances
943 which are attached to this class.
945 =item B<< $metaclass->calculate_all_roles_with_inheritance >>
947 This will return a unique array of C<Moose::Meta::Role> instances
948 which are attached to this class, and each of this class's ancestors.
950 =item B<< $metaclass->add_role($role) >>
952 This takes a L<Moose::Meta::Role> object, and adds it to the class's
953 list of roles. This I<does not> actually apply the role to the class.
955 =item B<< $metaclass->role_applications >>
957 Returns a list of L<Moose::Meta::Role::Application::ToClass>
958 objects, which contain the arguments to role application.
960 =item B<< $metaclass->add_role_application($application) >>
962 This takes a L<Moose::Meta::Role::Application::ToClass> object, and
963 adds it to the class's list of role applications. This I<does not>
964 actually apply any role to the class; it is only for tracking role
967 =item B<< $metaclass->does_role($role) >>
969 This returns a boolean indicating whether or not the class does the specified
970 role. The role provided can be either a role name or a L<Moose::Meta::Role>
971 object. This tests both the class and its parents.
973 =item B<< $metaclass->excludes_role($role_name) >>
975 A class excludes a role if it has already composed a role which
976 excludes the named role. This tests both the class and its parents.
978 =item B<< $metaclass->add_attribute($attr_name, %params|$params) >>
980 This overrides the parent's method in order to allow the parameters to
981 be provided as a hash reference.
983 =item B<< $metaclass->constructor_class($class_name) >>
985 =item B<< $metaclass->destructor_class($class_name) >>
987 These are the names of classes used when making a class immutable. These
988 default to L<Moose::Meta::Method::Constructor> and
989 L<Moose::Meta::Method::Destructor> respectively. These accessors are
990 read-write, so you can use them to change the class name.
992 =item B<< $metaclass->error_class($class_name) >>
994 The name of the class used to throw errors. This defaults to
995 L<Moose::Error::Default>, which generates an error with a stacktrace
996 just like C<Carp::confess>.
998 =item B<< $metaclass->throw_error($message, %extra) >>
1000 Throws the error created by C<create_error> using C<raise_error>
1006 See L<Moose/BUGS> for details on reporting bugs.