class refactoring part 3: external constructors

Author: michaelficarra

lib/coffee-script/compiler.js

@@ -345,21 +345,23 @@ class exports.Compiler
       else fn
     ]
 
-    [CS.Class, ({nameAssignee, parent, name, block}) ->
+    [CS.Class, ({nameAssignee, parent, name, ctor, block, compile}) ->
       args = []
       params = []
       parentRef = genSym 'super'
       block = forceBlock block
 
-      # TODO: make this nicer somehow
-      for fd in block.body when fd.instanceof JS.FunctionDeclaration
-        ctor = fd
-        ctor.id = name
-        break
       unless ctor?
-        block.body.unshift ctor = new JS.FunctionDeclaration name, [], new JS.BlockStatement []
-
-      if @boundMembers.length
+        ctor = new JS.FunctionDeclaration name, [], new JS.BlockStatement []
+      ctor.id = name
+      # handle external constructors
+      if @ctor? and not @ctor.expression.instanceof CS.Functions
+        ctorRef = genSym 'externalCtor'
+        ctor.body.body.push makeReturn new JS.CallExpression (memberAccess ctorRef, 'apply'), [new JS.ThisExpression, new JS.Identifier 'arguments']
+        block.body.unshift stmt new JS.AssignmentExpression '=', ctorRef, compile @ctor.expression
+      block.body.unshift ctor
+
+      if @boundMembers? and @boundMembers.length > 0
         instance = genSym 'instance'
         for memberName in @boundMembers
           member = memberAccess new JS.ThisExpression, memberName
@@ -390,7 +392,6 @@ class exports.Compiler
       if @expression.instanceof CS.Functions
         new JS.FunctionDeclaration tmpName, expression.params, forceBlock expression.body
       else
-        # TODO: support external ctors
         new JS.FunctionDeclaration tmpName, [], new JS.BlockStatement []
     ]
     [CS.ClassProtoAssignOp, ({assignee, expression, compile}) ->

lib/coffee-script/nodes.js

@@ -504,17 +504,24 @@ loop
 
 class
   = CLASS name:(_ Assignable)? parent:(_ EXTENDS _ (functionLiteral / assignmentExpression))? body:classBody {
+      var ctor = null;
       var raw = 'class' + (name ? name[0] + name[1].raw : '') +
         (parent ? parent[0] + 'parent' + parent[2] + parent[3].raw : '') +
         body.raw;
       name = name ? name[1] : null;
       parent = parent ? parent[3] : null;
-      var boundMembers = foldl(function(memo, m) {
-        if(m.instanceof(CS.ClassProtoAssignOp) && m.expression.instanceof(CS.BoundFunction))
-          return memo.concat(m.assignee.data.toString());
-        return memo;
-      }, [], body.block.statements);
-      return new CS.Class(name, parent, body.block, boundMembers).r(raw).p(line, column);
+      var boundMembers = [];
+      var stmts = body.block.statements;
+      for(var i = 0, l = stmts.length; i < l; ++i) {
+        var m = stmts[i];
+        if(m.instanceof(CS.Constructor)) {
+          ctor = m;
+          stmts.splice(i, 1); --i; --l;
+        } else if(m.instanceof(CS.ClassProtoAssignOp) && m.expression.instanceof(CS.BoundFunction)) {
+          boundMembers.push(m.assignee.data.toString());
+        }
+      }
+      return new CS.Class(name, parent, ctor, body.block, boundMembers).r(raw).p(line, column);
     }
   classBody
     = ws:_ t:TERMINDENT b:classBlock d:DEDENT { return {block: b, raw: ws + t + b.raw + d}; }
@@ -531,12 +538,20 @@ class
       }
   classStatement
     = classProtoAssignment
+    / constructor
     / expression
+  constructor
+    = key:ObjectInitialiserKeys ws0:_ ":" ws1:_ e:expression {
+        if(!key.instanceof(CS.String, CS.Identifier) || key.data !== 'constructor') return null;
+        var raw = key.raw + ws0 + ":" + ws1 + e.raw;
+        if(e.instanceof(CS.BoundFunction))
+          e = new CS.Function(e.parameters, e.block).r(e.raw).p(e.line, e.column);
+        return new CS.Constructor(e).r(raw).p(line, column);
+      }
   classProtoAssignment
     = key:ObjectInitialiserKeys ws0:_ ":" ws1:_ e:expression {
+        if(key.data === 'constructor') return null;
         var raw = key.raw + ws0 + ":" + ws1 + e.raw;
-        if(key.instanceof(CS.String, CS.Identifier) && key.data === 'constructor')
-          return new CS.Constructor(e).r(raw).p(line, column);
         return new CS.ClassProtoAssignOp(key, e).r(raw).p(line, column);
       }
 

lib/coffee-script/parser.js

@@ -136,15 +136,15 @@ createNodes
     ForIn: [['valAssignee', 'keyAssignee', 'expression', 'step', 'filterExpr', 'block']] # :: Assignable -> Maybe Assignable -> Exprs -> Exprs -> Maybe Exprs -> Maybe Exprs -> ForIn
     ForOf: [['isOwn', 'keyAssignee', 'valAssignee', 'expression', 'filterExpr', 'block']] # :: bool -> Assignable -> Maybe Assignable -> Exprs -> Maybe Exprs -> Maybe Exprs -> ForOf
     Switch: [['expression', 'cases', 'elseBlock']] # :: Maybe Exprs -> [SwitchCase] -> Maybe Exprs -> Switch
-    # TODO: test/consequent
+    # TODO: tests/consequent
     SwitchCase: [['conditions', 'block']] # :: [Exprs] -> Maybe Expr -> SwitchCase
     Try: [['block', 'catchAssignee', 'catchBlock', 'finallyBlock']] # :: Exprs -> Maybe Assignable -> Maybe Exprs -> Maybe Exprs -> Try
     While: [['condition', 'block']] # :: Exprs -> Maybe Exprs -> While
 
     ArrayInitialiser: [['members']] # :: [ArrayInitialiserMembers] -> ArrayInitialiser
     ObjectInitialiser: [['members']] # :: [ObjectInitialiserMember] -> ObjectInitialiser
     ObjectInitialiserMember: [['key', 'expression']] # :: ObjectInitialiserKeys -> Exprs -> ObjectInitialiserMember
-    Class: [['nameAssignee', 'parent', 'block', 'boundMembers']] # :: Maybe Assignable -> Maybe Exprs -> Maybe Exprs -> [string] -> Class
+    Class: [['nameAssignee', 'parent', 'ctor', 'block', 'boundMembers']] # :: Maybe Assignable -> Maybe Exprs -> Maybe Exprs -> Maybe Exprs -> [string] -> Class
     Constructor: [['expression']] # :: Exprs -> Constructor
     Functions: [ ['parameters', 'block'],
       Function: null # :: [Parameters] -> Maybe Exprs -> Function