make inlining a bit more easily extensible

[gitmo/Class-MOP.git] / lib / Class / MOP / Method / Accessor.pm

diff --git a/lib/Class/MOP/Method/Accessor.pm b/lib/Class/MOP/Method/Accessor.pm
index 08bcbd1..5464f8f 100644 (file)
--- a/lib/Class/MOP/Method/Accessor.pm
+++ b/lib/Class/MOP/Method/Accessor.pm
@@ -91,137 +91,138 @@ sub _initialize_body {
 ## generators
 
 sub _generate_accessor_method {
-    my $attr = (shift)->associated_attribute;
-    return sub {
-        $attr->set_value($_[0], $_[1]) if scalar(@_) == 2;
-        $attr->get_value($_[0]);
-    };
-}
+    my $self = shift;
+    my $attr = $self->associated_attribute;
 
-sub _generate_reader_method {
-    my $attr = (shift)->associated_attribute;
     return sub {
-        confess "Cannot assign a value to a read-only accessor" if @_ > 1;
+        if (@_ >= 2) {
+            $attr->set_value($_[0], $_[1]);
+        }
         $attr->get_value($_[0]);
     };
 }
 
-
-sub _generate_writer_method {
-    my $attr = (shift)->associated_attribute;
-    return sub {
-        $attr->set_value($_[0], $_[1]);
-    };
-}
-
-sub _generate_predicate_method {
-    my $attr = (shift)->associated_attribute;
-    return sub {
-        $attr->has_value($_[0])
-    };
-}
-
-sub _generate_clearer_method {
-    my $attr = (shift)->associated_attribute;
-    return sub {
-        $attr->clear_value($_[0])
-    };
-}
-
-## Inline methods
-
 sub _generate_accessor_method_inline {
     my $self = shift;
     my $attr = $self->associated_attribute;
 
-    my $code = try {
+    return try {
         $self->_compile_code([
             'sub {',
-                $attr->inline_set('$_[0]', '$_[1]'),
-                    'if scalar(@_) == 2;',
-                $attr->inline_get('$_[0]') . ';',
+                'if (@_ >= 2) {',
+                    $attr->_inline_set_value('$_[0]', '$_[1]'),
+                '}',
+                $attr->_inline_get_value('$_[0]'),
             '}',
         ]);
     }
     catch {
         confess "Could not generate inline accessor because : $_";
     };
+}
+
+sub _generate_reader_method {
+    my $self = shift;
+    my $attr = $self->associated_attribute;
 
-    return $code;
+    return sub {
+        confess "Cannot assign a value to a read-only accessor"
+            if @_ > 1;
+        $attr->get_value($_[0]);
+    };
 }
 
 sub _generate_reader_method_inline {
     my $self = shift;
     my $attr = $self->associated_attribute;
 
-    my $code = try {
+    return try {
         $self->_compile_code([
             'sub {',
                 'confess "Cannot assign a value to a read-only accessor"',
                     'if @_ > 1;',
-                $attr->inline_get('$_[0]') . ';',
+                $attr->_inline_get_value('$_[0]'),
             '}',
         ]);
     }
     catch {
         confess "Could not generate inline reader because : $_";
     };
+}
 
-    return $code;
+sub _generate_writer_method {
+    my $self = shift;
+    my $attr = $self->associated_attribute;
+
+    return sub {
+        $attr->set_value($_[0], $_[1]);
+    };
 }
 
 sub _generate_writer_method_inline {
     my $self = shift;
     my $attr = $self->associated_attribute;
 
-    my $code = try {
+    return try {
         $self->_compile_code([
             'sub {',
-                $attr->inline_set('$_[0]', '$_[1]') . ';',
+                $attr->_inline_set_value('$_[0]', '$_[1]'),
             '}',
         ]);
     }
     catch {
         confess "Could not generate inline writer because : $_";
     };
+}
+
+sub _generate_predicate_method {
+    my $self = shift;
+    my $attr = $self->associated_attribute;
 
-    return $code;
+    return sub {
+        $attr->has_value($_[0])
+    };
 }
 
 sub _generate_predicate_method_inline {
     my $self = shift;
     my $attr = $self->associated_attribute;
 
-    my $code = try {
+    return try {
         $self->_compile_code([
             'sub {',
-                $attr->inline_has('$_[0]') . ';',
+                $attr->_inline_has_value('$_[0]'),
             '}',
         ]);
     }
     catch {
         confess "Could not generate inline predicate because : $_";
     };
+}
 
-    return $code;
+sub _generate_clearer_method {
+    my $self = shift;
+    my $attr = $self->associated_attribute;
+
+    return sub {
+        $attr->clear_value($_[0])
+    };
 }
 
 sub _generate_clearer_method_inline {
     my $self = shift;
     my $attr = $self->associated_attribute;
 
-    my $code = try {
+    return try {
         $self->_compile_code([
             'sub {',
-                $attr->inline_clear('$_[0]') . ';',
+                $attr->_inline_clear_value('$_[0]'),
             '}',
         ]);
     }
     catch {
         confess "Could not generate inline clearer because : $_";
     };
-
-    return $code;
 }
 
 1;