From eba32ed4cb8b43ca0f745538a43bfbd3ee67d72a Mon Sep 17 00:00:00 2001
From: Mike Gerwitz <mike@mikegerwitz.com>
Date: Mon, 24 Jan 2011 23:28:48 -0500
Subject: [PATCH] Beginning to move Class over to use member builders

---
 lib/class.js          | 43 +++++++++++++++++++++++++++++++------------
 lib/member_builder.js |  4 +++-
 lib/util.js           |  1 +
 3 files changed, 35 insertions(+), 13 deletions(-)

diff --git a/lib/class.js b/lib/class.js
index a4cce68..ec398cd 100644
--- a/lib/class.js
+++ b/lib/class.js
@@ -214,7 +214,9 @@ var extend = ( function( extending )
             prototype = new base();
 
         var properties       = {},
-            members          = member_builder.initMembers( prototype ),
+            members          = member_builder.initMembers(
+                prototype, prototype, prototype
+            ),
             abstract_methods = ( base.abstractMethods || [] ).slice();
 
         // it's much faster to lookup a hash than it is to iterate through an
@@ -226,35 +228,52 @@ var extend = ( function( extending )
             abstract_map[ method ] = i;
         }
 
-        util.propCopy( props, prototype, {
-            each: function( name, value )
+        util.propParse( props, {
+            each: function( name, value, keywords )
             {
                 // disallow use of our internal __initProps() method
                 if ( name === '__initProps' )
                 {
                     throw new Error( "__initProps is a reserved method" );
                 }
-
-                this.performDefault( name, value );
             },
 
-            property: function( name, value )
+            property: function( name, value, keywords )
             {
                 properties[ name ] = value;
-                this.performDefault( name, value );
+
+                member_builder.buildProp(
+                    members, null, name, value, keywords
+                );
             },
 
-            method: function( name, func, is_abstract )
+            getter: function( name, value, keywords )
             {
-                var pre = prototype[ name ];
+                member_builder.buildGetter(
+                    members, null, name, value, keywords
+                );
+            },
 
-                this.performDefault( name, func, is_abstract );
+            setter: function( name, value, keywords )
+            {
+                member_builder.buildSetter(
+                    members, null, name, value, keywords
+                );
+            },
 
-                if ( ( pre === undefined ) && is_abstract  )
+            method: function( name, func, is_abstract, keywords )
+            {
+                member_builder.buildMethod(
+                    members, null, name, func, keywords
+                );
+
+                if ( is_abstract )
                 {
                     abstract_methods.push( name );
                 }
-                else if ( pre && ( is_abstract === false ) )
+                else if ( ( abstract_map[ name ] !== undefined )
+                    && ( is_abstract === false )
+                )
                 {
                     // if this was a concrete method, then it should no longer
                     // be marked as abstract
diff --git a/lib/member_builder.js b/lib/member_builder.js
index df4c623..d7c4c53 100644
--- a/lib/member_builder.js
+++ b/lib/member_builder.js
@@ -75,7 +75,9 @@ exports.buildMethod = function( members, meta, name, value, keywords )
     }
 
     // ensure parameter list is at least the length of its supertype
-    if ( prev && ( value.length < ( prev.__length || prev.length ) ) )
+    if ( prev && (
+        ( value.__length || value.length ) < ( prev.__length || prev.length )
+    ) )
     {
         throw new TypeError(
             "Declaration of method '" + name + "' must be compatiable " +
diff --git a/lib/util.js b/lib/util.js
index e24551a..111c34e 100644
--- a/lib/util.js
+++ b/lib/util.js
@@ -381,6 +381,7 @@ exports.createAbstractMethod = function()
 
     exports.defineSecureProp( method, 'abstractFlag', true );
     exports.defineSecureProp( method, 'definition', definition );
+    exports.defineSecureProp( method, '__length', arguments.length );
 
     return method;
 };