import t, { is, isa, assertOneOf } from '../types'

import { restToSpread, spreadIsAlreadySafe } from '../helpers/variables'

import { getFunctionParent } from '../helpers/blocks'

export containsSuperCall(path) ->

let hasSuper = false

path.traverse({

noScope: true

Class(path): void -> path.skip()

// XXX: this may not be necessary due to super calls in free functions

// being syntax errors caught by js engine.

Function(path): void -> path.skip()

LscFunction(path): void -> path.skip()

Super(superPath): void ->

if is("CallExpression", superPath.parentPath):

now hasSuper = true

superPath.stop()

})

hasSuper

export ensureConstructor(classPath, constructorBodyPath, withSuper = true) ->

if not constructorBodyPath:

emptyConstructor = t.classMethod(

"constructor"

t.identifier("constructor")

[]

t.blockStatement([])

)

// XXX: this marks this constructor for super insertion.

// why is it doing it like this? seems hackish, rethink

emptyConstructor.skinny = true

classPath.get("body").unshiftContainer("body", emptyConstructor)

now constructorBodyPath = classPath.get("body.body.0.body")

if(

withSuper and

classPath.node.superClass and

constructorBodyPath.parentPath.node.skinny and

not containsSuperCall(constructorBodyPath)

):

superCall = if constructorBodyPath.parentPath.node.params.length:

// constructor(<args>) -> super(<args>)

t.expressionStatement(

t.callExpression(

t.super()

constructorBodyPath.parentPath.node.params~restToSpread!

)

)

else:

// constructor(...args) -> super(...args)

let argsUid = classPath.scope.generateUidIdentifier("args");

constructorBodyPath.parentPath.node.params = [t.restElement(argsUid)];

t.expressionStatement(

t.callExpression(t.super(), [

t.spreadElement(argsUid)~spreadIsAlreadySafe!

])

)

constructorBodyPath.unshiftContainer("body", superCall)

constructorBodyPath

export bindMethodsInConstructor(classPath, constructorPath, methodIds) ->

// `this.method = this.method.bind(this);`

assignments = [...for elem methodId in methodIds:

assertOneOf(methodId, ["Identifier", "Expression"])

isComputed = !is("Identifier", methodId)

thisDotMethod = t.memberExpression(t.thisExpression(), methodId, isComputed)

[t.expressionStatement(

t.assignmentExpression("="

thisDotMethod

t.callExpression(

t.memberExpression(thisDotMethod, t.identifier("bind"))

[t.thisExpression()]

)

)

)]

]

// directly after each instance of super(), insert the thingies there.

if (classPath.node.superClass) {

constructorPath.traverse({

Super(superPath) {

if (!superPath.parentPath~isa("CallExpression")) return;

let superStatementPath = superPath.getStatementParent();

// things get super weird when you return super();

// TODO: consider trying to handle it

let enclosingReturn = superPath

.findParent((p) => p~isa("ReturnStatement") && p~getFunctionParent() === constructorPath.parentPath);

if (enclosingReturn) throw new Error("Can't use => with `return super()`; try removing `return`.");

superStatementPath.insertAfter(assignments);

return

}

});

} else {

constructorPath.unshiftContainer("body", assignments);

}

export bindMethods(path, methodIds) ->

let assignId, inExpression = false;

if (path~isa("ClassDeclaration")) {

now assignId = path.node.id;

} else if (

path.parentPath~isa("AssignmentExpression") &&

path.parentPath.parentPath~isa("ExpressionStatement")

) {

now assignId = path.parentPath.node.left;

} else if (path.parentPath~isa("VariableDeclarator")) {

now assignId = path.parentPath.node.id;

} else {

let id = path~isa("Class") ? "class" : "obj";

now assignId = path.getStatementParent().scope.generateDeclaredUidIdentifier(id);

now inExpression = true;

}

assertOneOf(assignId, ["Identifier", "MemberExpression"]);

let assignments = methodIds.map((methodId) => {

// could be computed, eg `['blah']() => {}`

assertOneOf(methodId, ["Identifier", "Expression"]);

let isComputed = !(methodId~isa("Identifier"));

let objDotMethod = t.memberExpression(assignId, methodId, isComputed);

let bind = t.callExpression(

t.memberExpression(objDotMethod, t.identifier("bind")),

[assignId]

);

return t.assignmentExpression("=", objDotMethod, bind);

});

if (inExpression) {

path.replaceWith(t.sequenceExpression([

t.assignmentExpression("=", assignId, path.node),

...assignments,

assignId

]));

} else {

path.getStatementParent().insertAfter(

assignments.map((a) => t.expressionStatement(a))

);

}

enumerateClassBody(path) ->

fatArrows = []

fatStaticArrows = []

let constructorPath = null

body = path.node.body

body.forEach((method, i) => {

if (!t.isMethod(method)) return;

if (method.kind === "constructor") {

now constructorPath = path.get(`body.${i}.body`);

} else if (method.static && method.skinny === false) {

fatStaticArrows.push(method.key);

method.skinny = true; // prevent infinite recursion

} else if (method.skinny === false) {

fatArrows.push(method.key);

method.skinny = true; // prevent infinite recursion

}

});

{ fatArrows, fatStaticArrows, constructorPath }

export transformClassBody(path): void ->

let { fatArrows, fatStaticArrows, constructorPath } = enumerateClassBody(path)

let maybeAddSuper = path.parentPath.node.superClass && constructorPath;

if (fatArrows.length || maybeAddSuper) {

now constructorPath = ensureConstructor(path.parentPath, constructorPath, true);

}

if (fatArrows.length) {

bindMethodsInConstructor(path.parentPath, constructorPath, fatArrows);

}

if (fatStaticArrows.length) {

bindMethods(path.parentPath, fatStaticArrows);

}

export transformObjectMethod(path): void ->

{ node } = path

// Transform methods with fat arrows

if (node.kind != "method") or (node.skinny != false): return

// Fat arrows should get lexical `this`

// Transform to an objectProperty with an ArrowFunctionExpression body

func = t.arrowFunctionExpression(node.params, node.body, node.async)

func.generator = node.generator

func.returnType = node.returnType

func.typeParameters = node.typeParameters

prop = t.objectProperty(node.key, func, node.computed, false, node.decorators)

path.replaceWith(prop)