When can body be undefined or null in vanilla espree?

[G-Rath]

I'm working on converting eslint-plugin-jest to typescript, and have come across a type definition that I can't reproduce at runtime.

While converting no-test-callbacks, I found out that it's apparently possible for the body of a FunctionDeclaration to be null.

This has required me to add a null check in order to please typescript.

This in turn upsets our coverage b/c that branch is never tested, leading me here as I've not been able to write any code that reproduces the defined type.

Hence: how can I have a FunctionDeclaration w/ a body of null at runtime?

I suspect this heavily relates to #420, but theres too many moving parts for me to properly track :)

[bradzacher]

in vanilla espree?
I have no idea. I don't think it's possible there.

In typescript there are a number of places, such as:

// declarations
declare function foo(): void;

// overloads
function bar(): void;
function bar(arg?:string) {}

// abstract
abstract class Foo {
  abstract meth(): string;

  // class method overloads
  meth2(): void
  meth2(arg?: string) {}
}

[G-Rath]

That's what my investigation reveals as well, except that at those points the node type stops being FunctionDeclaration, instead becoming a TS node type (TSDeclareFunction & TSAbstractMethodDefinition), or just don't have a body at all (in the case of MethodDefinition)

It's all sounding to me like the FunctionDeclaration & FunctionExpression interfaces should redefine body as being just BlockStatement.

For reference:

// declarations
declare function foo(): void; // TSDeclareFunction

// overloads
function bar(): void; // TSDeclareFunction
function bar(arg?:string) {} // FunctionDeclaration (w/ body of type BlockStatement)

// abstract
abstract class Foo {
  abstract meth(): string; // TSAbstractMethodDefinition

  // class method overloads
  meth2(): void // MethodDefinition (w/ value of TSEmptyBodyFunctionExpression)
  meth2(arg?: string) {} // MethodDefinition (w/ value of FunctionExpression)
}

[bradzacher]

I'm not actually sure tbh.
I can't remember the cases.

The type of body is optional in the core typescript types:
https://github.com/microsoft/TypeScript/blob/97b5671f998bdc46db6e9b5cdc2f61a66efcbe7d/src/compiler/types.ts#L1051-L1084

I didn't realise it, but in #156, it added handling to convert function declarations with no body into TSFunctionDeclaration (https://github.com/typescript-eslint/typescript-eslint/pull/156/files#diff-68b2b0b0d2d0ff1846b1114472008332R674)

So it looks like there's no case now that a FunctionDeclaration can have no body?

FunctionExpression has no such handling, so the body will have to remain nullable.
Technically via the parser, we transform empty bodied function expressions into a new type TSEmptyBodyFunctionExpression, however the types come from typescript-estree, which does not have this conversion.

typescript-eslint/packages/parser/src/parser.ts

Lines 94 to 98 in 93f72e3

	case 'FunctionExpression':
	if (!node.body) {
	node.type = `TSEmptyBody${node.type}` as any;
	}
	break;

Maybe we should move that conversion into typescript-estree so we can simplify the types?

cc @JamesHenry / @uniqueiniquity

[G-Rath]

Any progress on this?

I'm happy to help if there's anything I can do 🙂

[bradzacher]

Happy to accept a PR, I hadn't looked into it any further.

[armano2]

note. why it stayed in this way

Initially there was a lot of additional conversions from AST produced by ts-estree in parser, most of them was cleared out, and looks like i forgot about this one.

this is part of legacy code from: https://github.com/eslint/typescript-eslint-parser/blob/master/parser.js#L46-L58

and last change to this was done in PR https://github.com/eslint/typescript-eslint-parser/pull/596/files#diff-09461573a85e2d94f056dd6814769042

those changes was done before mono-repo, and at that time there was a lot of misalignment's between projects, and pushing any breaking changes was way way harder than now.