Semi-colon requirements/spec for TypeScript-specific concepts

[JamesHenry]

I apologise for deviating from the standard template, but I strongly feel this low-level question can only be answered by a member of the TypeScript team.

I began asking this in the gitter channel but I think this is more appropriate in this case.

Background

I am a member of the ESLint team working on the typescript-eslint-parser project. We are super excited to bring TypeScript support to ESLint and be able to bring together two awesome communities.

We are currently looking into how we could extend existing rules to "just work". Early findings and more background to that is available here: eslint/typescript-eslint-parser#77

Specifically this has led me to need to determine how semi-colon behaviour is defined for TypeScript-specific statements?

For example, if we want want to extend the semi or no-extra-semi rules in ESLint to take TypeScript specific nodes into account, we first need to define when a semi-colon could be used (whether required or not).

Some examples:

Type aliases seem to work just fine with or without semi-colons:

type Result<T> = Success<T> | Failure
type Result<T> = Success<T> | Failure;

Interfaces seem to allow pretty much anything as a delimiter:

interface Foo {
    bar: boolean
    baz: string;
    qux: any,
}

Is it spec'd somewhere, officially or unofficially, how these statements and delimiters should behave?

Many thanks in advance!

[mhegazy]

The grammar is specified in the TS spec, see https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md#A. The TS grammar is defined as an addition to the ES6 grammar. so it only handles TS specific.

I would consider the spec "correct". but there are productions that the compiler would allow and are not mentioned in the spec. e.g. allowing missing ; for type alias declaration. i would consider this a bug in the compiler.

So in general, I would refer to the spec for the expected behavior. if the expected behavior is inconsistent with other parts of the language, or if the implementation deviates from the spec, these should be either spec or implementation bugs, and we can address these.

[JamesHenry]

e.g. allowing missing ; for type alias declaration. i would consider this a bug in the compiler.

That's an interesting point of view. ASI in JavaScript is relied upon by many who prefer to write their code with no (extra) semi-colons (myself included), so it seems very natural to me that TypeScript, as a superset of JS would have its own notion of ASI...

As someone who prefers no extra semis for example, I have always written type alias statements and interface members without semi-colons - I never looked that up when learning, it just seemed a natural extension of my JavaScript.

How do you feel about looking at it from the opposite standpoint - rather than a bug in the compiler, it is a feature missing from the docs?

[JamesHenry]

I am thinking about it from a "user perspective" here because the linter's job is naturally to lint and provide rules around whatever is valid (whether spec'ed or not) and actively being used by people. I am sure many will write their TS in the way I have described above

[ShawnTalbert]

I would love for semicolons to be officially optional in the TS spec. I'm another one of those 'no extra semis' people.

[mhegazy]

well semicolons are not required after declarations. e.g. interface, namespace, enum, etc.. they are not part of the production. so a semicolon after an interface is parsed as an empty statement (i.e. error in a .d.ts file). and personally i believe allowing semicolons here would be wrong.

Semicolon is optional for JS declarations e.g. const, let, var, etc.. (following the ASI rules)

The only place that it is required by the grammar is the type alias declaration. and the implementation enforces the same ASI rules.

so i do not think there is a general issue here. it is only type alias declarations. personally i believe it should have a semicolon. but we would be open to change the rules for this one.

[JamesHenry]

Thanks @mhegazy, that has definitely clarified things a bit.

I am sorry for the confusion around semi-colons and interfaces - I didn't mean after the interface declaration I meant after the member(s) within the interface, as in my example above:

interface Foo {
    bar: boolean
    baz: string;
    qux: any,
}

[mhegazy]

; or , should be required i would say. ; would be my pick for style, if i may.

[JamesHenry]

Ok great. I think in the case of interface members, then, we would look implement an additional rule, whereas we will probably extend the core rule to account for the type alias declaration statement as it behaves much more like a JS VariableDeclaration.

[DanielRosenwasser]

For the record, you can get get a sense of the right behavior by looking for occurrences of canParseSemicolon(), and scanner.hasPrecedingLineBreak() in the parser.