seems to not work with es6 method notation

[serapath]

var parsefn = require('parse-function')
var o = { fn () { } }
parsefn(o.fn) // throws

otherwise, the module is exactly what i was looking for. thx :-)

[tunnckoCore]

thanks for the report. what version you use and what err is thrown?

[lrowe]

I'm seeing this too with version 3.0.0:

> parsefn(o.fn)
SyntaxError: Unexpected token, expected ; (1:5)

> o.fn.toString()
'fn() { }'

[tunnckoCore]

@lrowe thanks! I'll look.

[tunnckoCore]

@lrowe @serapath, sadly I don't see how can support this, since such function don't have correct toString. It is possible of course. The only thing that I think is to make kinda hack - detect if result of to string is such, then wrap it with 'var o = { ' + val.toString() + ' }' an after than pass it to the parser and visit the ast.

I can do it, but it will work for Babylon, it is not guaraneed that it would if one want to use other parser, because the ASTs may be a bit different.

[tunnckoCore]

Also, it going more worse when var b = { *[Symbol.iterator]() {} } for example. Another case is class methods. I don't it would be implemented, because it is kinda tricky and too hack, so we won't support such in near future.

But any ideas and trick that work without so magic is welcome.

[lrowe]

I'm not sure it's necessarily that bad, mostly we're just missing the 'function' part:

> parsefn('function ' + o.fn.toString())
{ name: 'fn', body: ' ', args: [], params: '' }

Maybe we can detect with a regex?

That doesn't work for the iterator case, but looks like there's a bug with anonymous iterators even without the method syntax:

> var x = function *() {}
undefined
> x.toString()
'function* () {}'
> parsefn(x)
SyntaxError: Unexpected token (1:10)

Without the iterator / non anonymous generators work:

> var y = function(){}
undefined
> y.toString()
'function (){}'
> parsefn(y)
{ name: 'anonymous', body: '', args: [], params: '' }
> function* gen() {}
undefined
> gen.toString()
'function* gen() {}'
> parsefn(gen)
{ name: 'gen', body: '', args: [], params: '' }

(Unrelated, but maybe it would be better to have name: undefined here to distinguish from function anonymous(){}.)

[tunnckoCore]

mostly we're just missing the 'function' part:

I don't think it would be just that.

better to have name: undefined

No. Kinda like to have defaults. In both way you finally will kinda write "|| anonymous" somewhere else.

'function* () {}'

yep, because the hack that is done. And that hack exists because parsers throw when anonymous function is passed.

Try

babylon.parse('function () {}')
babylon.parse('function * () {}')
babylon.parse('() => {}') // maybe not throws? don't remember, so i'm not sure

Btw, just seen that there is missing tests for generator fns, hehe, thanks.

[lrowe]

better to have name: undefined
No. Kinda like to have defaults. In both way you finally will kinda write "|| anonymous" somewhere else.

I see the isAnonymous() method so seems that is covered. Might be nice if the name of an anonymous function was an invalid identifier to avoid confusion with function anonymous() {}.

yep, because the hack that is done. And that hack exists because parsers throw when anonymous function is passed.

Wrapping in parentheses to parse as a FunctionExpression rather than a FunctionDeclaration should avoid the need for the hack:

babylon.parse('(function () {})')
babylon.parse('(function* () {})')

The resulting structures are only slightly different:

> babylon.parse('(function foo() {})').program.body[0].expression
Node {
  type: 'FunctionExpression',
  start: 1,
  end: 18,
  loc: 
   SourceLocation {
     start: Position { line: 1, column: 1 },
     end: Position { line: 1, column: 18 } },
  id: 
   Node {
     type: 'Identifier',
     start: 10,
     end: 13,
     loc: SourceLocation { start: [Object], end: [Object], identifierName: 'foo' },
     name: 'foo' },
  generator: false,
  expression: false,
  async: false,
  params: [],
  body: 
   Node {
     type: 'BlockStatement',
     start: 16,
     end: 18,
     loc: SourceLocation { start: [Object], end: [Object] },
     body: [],
     directives: [] },
  extra: { parenthesized: true, parenStart: 0 } }

> babylon.parse('function foo() {}').program.body[0]
Node {
  type: 'FunctionDeclaration',
  start: 0,
  end: 17,
  loc: 
   SourceLocation {
     start: Position { line: 1, column: 0 },
     end: Position { line: 1, column: 17 } },
  id: 
   Node {
     type: 'Identifier',
     start: 9,
     end: 12,
     loc: SourceLocation { start: [Object], end: [Object], identifierName: 'foo' },
     name: 'foo' },
  generator: false,
  expression: false,
  async: false,
  params: [],
  body: 
   Node {
     type: 'BlockStatement',
     start: 15,
     end: 17,
     loc: SourceLocation { start: [Object], end: [Object] },
     body: [],
     directives: [] } }

[tunnckoCore]

Hm. Good catch. Can try these days. Or if you want go with PR :)

I see the isAnonymous() method so seems that is covered.

Maybe make sense, yea. Hm. So if it is real anonymous to not have name set, if it is function named anonymous to be name: 'anonymous', so users should relay on .isAnonymous not on the name. Maybe for v4, yea.

[lrowe]

Forgot the part relevant to this issue... There's still the problem with methods. I've been unable to come up with a regular expression which correctly distinguishes methods from functions in all permutations of symbols/strings, arrow/regular, named/unnamed, methods/non-methods.

Instead we could first attempt parsing the function wrapped in'(' + fn.toString() + ')' and if babylon.parse raises a SyntaxError, attempt wrapping in '(function ' + fn.toString() + ')' to parse as a method.

If it fails again then it's probably native code about which we have nothing to go on (e.g. 'function Boolean() { [native code] }'.)

[tunnckoCore]

That's why this package exists and uses javascript parser. :D But there's also https://github.com/tunnckoCore/function-arguments if anyone want just args, based on RegExp.

if babylon.parse raises a SyntaxError

Something like that, yea. But maybe it would be more better if just toString and check if it starts with function (with trailing space).

[lrowe]

Something like that, yea. But maybe it would be more better if just toString and check if it starts with function (with trailing space).

Parsing with Regexp is a non starter in the face of default parameter values (which can be any Expression.) I'd thought I could find a RegExp that would work for just distinguishing methods/arrows/regular functions by matching up until the parameters, but I failed.

This was my best attempt:

> function isMethod(fn) { var m = /(function)?(.*?)(=>|\()/.exec(fn.toString()); return Boolean(m && !m[1] && m[2] && m[3] === '('); }
undefined
> o = { fn() {}, *gen() {}, *[Symbol.iterator]() {}, [Symbol.for('sym')]() {} }
{ fn: [Function: fn], gen: [Function: gen] }
> isMethod(o.fn)
true
> isMethod(o.gen)
true
> isMethod(o[Symbol.iterator])
true
> isMethod(function foo() {})
false
> isMethod(function() {})
false
> isMethod(functionish => {})
false
> isMethod((a,b) => {})
false
>isMethod(o[Symbol.for('sym')])
false

Note the incorrect result for non-generator symbol methods which I'm unable to distinguish from an arrow function:

> o[Symbol.for('sym')].toString()
'() {}'