changelogs.md


lightscript/babylon-lightscript

Repository  -  API  -  Source

6.16.0

February 23, 2017

:rocket: New Feature

ESTree compatibility as plugin (#277) (Daniel Tschinder)

We finally introduce a new compatibility layer for ESTree. To put babylon into ESTree-compatible mode the new plugin estree can be enabled. In this mode the parser will output an AST that is compliant to the specs of ESTree

We highly recommend everyone who uses babylon outside of babel to use this plugin. This will make it much easier for users to switch between different ESTree-compatible parsers. We so far tested several projects with different parsers and exchanged their parser to babylon and in nearly all cases it worked out of the box. Some other estree-compatible parsers include acorn, esprima, espree, flow-parser, etc.

To enable estree mode simply add the plugin in the config:

{
  "plugins": [ "estree" ]
}

If you want to migrate your project from non-ESTree mode to ESTree, have a look at our Readme, where all deviations are mentioned.

Add a parseExpression public method (#213) (jeromew)

Babylon exports a new function to parse a single expression

import { parseExpression } from 'babylon';

const ast = parseExpression('x || y && z', options);

The returned AST will only consist of the expression. The options are the same as for parse()

Add startLine option (#346) (Raphael Mu)

A new option was added to babylon allowing to change the intial linenumber for the first line which is usually 1. Changing this for example to 100 will make line 1 of the input source to be marked as line 100, line 2 as 101, line 3 as 102, ...

Function predicate declaration (#103) (Panagiotis Vekris)

Added support for function predicates which flow introduced in version 0.33.0

declare function is_number(x: mixed): boolean %checks(typeof x === "number");

Allow imports in declare module (#315) (Daniel Tschinder)

Added support for imports within module declarations which flow introduced in version 0.37.0

declare module "C" {
  import type { DT } from "D";
  declare export type CT = { D: DT };
}

:eyeglasses: Spec Compliancy

Forbid semicolons after decorators in classes (#352) (Kevin Gibbons)

This example now correctly throws an error when there is a semicolon after the decorator:

class A {
@a;
foo(){}
}

Keywords are not allowed as local specifier (#307) (Daniel Tschinder)

Using keywords in imports is not allowed anymore:

import { default } from "foo";
import { a as debugger } from "foo";

Do not allow overwritting of primitive types (#314) (Daniel Tschinder)

In flow it is now forbidden to overwrite the primitve types "any", "mixed", "empty", "bool", "boolean", "number", "string", "void" and "null" with your own type declaration.

Disallow import type { type a } from … (#305) (Daniel Tschinder)

The following code now correctly throws an error

import type { type a } from "foo";

Don't parse class properties without initializers when classProperties is disabled and Flow is enabled (#300) (Andrew Levine)

Ensure that you enable the classProperties plugin in order to enable correct parsing of class properties. Prior to this version it was possible to parse them by enabling the flow plugin but this was not intended the behaviour.

If you enable the flow plugin you can only define the type of the class properties, but not initialize them.

Fix export default async function to be FunctionDeclaration (#324) (Daniel Tschinder)

Parsing the following code now returns a FunctionDeclaration AST node instead of FunctionExpression.

export default async function bar() {};

:nail_care: Polish

Improve error message on attempt to destructure named import (#288) (Brian Ng)

:bug: Bug Fix

Fix negative number literal typeannotations (#366) (Daniel Tschinder)

Ensure takeDecorators is called on exported class (#358) (Brian Ng)

ESTree: correctly change literals in all cases (#368) (Daniel Tschinder)

Correctly convert RestProperty to Assignable (#339) (Daniel Tschinder)

Fix #321 by allowing question marks in type params (#338) (Daniel Tschinder)

Fix #336 by correctly setting arrow-param (#337) (Daniel Tschinder)

Fix parse error when destructuring set with default value (#317) (Brian Ng)

Fix ObjectTypeCallProperty static (#298) (Dan Harper)

:house: Internal

Fix generator-method-with-computed-name spec (#360) (Alex Rattray)

Fix flow type-parameter-declaration test with unintended semantic (#361) (Alex Rattray)

Cleanup and splitup parser functions (#295) (Daniel Tschinder)

chore(package): update flow-bin to version 0.38.0 (#313) (greenkeeper[bot])

Call inner function instead of 1:1 copy to plugin (#294) (Daniel Tschinder)

Update eslint-config-babel to the latest version 🚀 (#299) (greenkeeper[bot])

Update eslint-config-babel to the latest version 🚀 (#293) (greenkeeper[bot])

devDeps: remove eslint-plugin-babel (#292) (Kai Cataldo)

Correct indent eslint rule config (#276) (Daniel Tschinder)

Fail tests that have expected.json and throws-option (#285) (Daniel Tschinder)

:memo: Documentation

Update contributing with more test info [skip ci] (#355) (Brian Ng)

Update API documentation (#330) (Timothy Gu)

Added keywords to package.json (#323) (Dmytro)

AST spec: fix casing of RegExpLiteral (#318) (Mathias Bynens)

6.15.0

January 10, 2017

:eyeglasses: Spec Compliancy

Add support for Flow shorthand import type (#267) (Jeff Morrison)

This change implements flows new shorthand import syntax and where previously you had to write this code:

import {someValue} from "blah";
import type {someType} from "blah";
import typeof {someOtherValue} from "blah";

you can now write it like this:

import {
  someValue,
  type someType,
  typeof someOtherValue,
} from "blah";

For more information look at this pull request.

flow: allow leading pipes in all positions (#256) (Vladimir Kurchatkin)

This change now allows a leading pipe everywhere types can be used:

var f = (x): | 1 | 2 => 1;

Throw error when exporting non-declaration (#241) (Kai Cataldo)

Previously babylon parsed the following exports, although they are not valid:

export typeof foo;
export new Foo();
export function() {};
export for (;;);
export while(foo);

:bug: Bug Fix

Don't set inType flag when parsing property names (#266) (Vladimir Kurchatkin)

This fixes parsing of this case:

const map = {
  [age <= 17] : 'Too young'
};

Fix source location for JSXEmptyExpression nodes (fixes #248) (#249) (James Long)

The following case produced an invalid AST

<div>{/* foo */}</div>

Use fromCodePoint to convert high value unicode entities (#243) (Ryan Duffy)

When high value unicode entities (e.g. 💩) were used in the input source code they are now correctly encoded in the resulting AST.

Rename folder to avoid Windows-illegal characters (#281) (Ryan Plant)

Allow this.state.clone() when parsing decorators (#262) (Alex Rattray)

:house: Internal

User external-helpers (#254) (Daniel Tschinder)

Add watch script for dev (#234) (Kai Cataldo)

Freeze current plugins list for "*" option, and remove from README.md (#245) (Andrew Levine)

Prepare tests for multiple fixture runners. (#240) (Daniel Tschinder)

Add some test coverage for decorators stage-0 plugin (#250) (Andrew Levine)

Refactor tokenizer types file (#263) (Sven SAULEAU)

Update eslint-config-babel to the latest version 🚀 (#273) (greenkeeper[bot])

chore(package): update rollup to version 0.41.0 (#272) (greenkeeper[bot])

chore(package): update flow-bin to version 0.37.0 (#255) (greenkeeper[bot])

6.14.1

November 17, 2016

:bug: Bug Fix

Allow "plugins": ["*"] (#229) (Daniel Tschinder)

{
  "plugins": ["*"]
}

Will include all parser plugins instead of specifying each one individually. Useful for tools like babel-eslint, jscodeshift, and ast-explorer.

6.14.0

November 16, 2016

:eyeglasses: Spec Compliancy

Throw error for reserved words enum and await (#195) (Kai Cataldo)

11.6.2.2 Future Reserved Words

Babylon will throw for more reserved words such as enum or await (in strict mode).

class enum {} // throws
class await {} // throws in strict mode (module)

Optional names for function types and object type indexers (#197) (Gabe Levi)

So where you used to have to write

type A = (x: string, y: boolean) => number;
type B = (z: string) => number;
type C = { [key: string]: number };

you can now write (with flow 0.34.0)

type A = (string, boolean) => number;
type B = string => number;
type C = { [string]: number };

Parse flow nested array type annotations like number[][] (#219) (Bernhard Häussner)

Supports these form now of specifying array types:

var a: number[][][][];
var b: string[][];

:bug: Bug Fix

Correctly eat semicolon at the end of DelcareModuleExports (#223) (Daniel Tschinder)

declare module "foo" { declare module.exports: number } 
declare module "foo" { declare module.exports: number; }  // also allowed now

:house: Internal

  • Count Babel tests towards Babylon code coverage (#182) (Moti Zilberman)
  • Fix strange line endings (#214) (Thomas Grainger)
  • Add node 7 (Daniel Tschinder)
  • chore(package): update flow-bin to version 0.34.0 (#204) (Greenkeeper)

6.13.1

October 26, 2016

:nail_care: Polish

  • Use rollup for bundling to speed up startup time (#190) (@drewml)
const babylon = require('babylon');
const ast = babylon.parse('var foo = "lol";');

With that test case, there was a ~95ms savings by removing the need for node to build/traverse the dependency graph.

Without bundling image

With bundling image

  • add clean command [skip ci] (#201) (Henry Zhu)
  • add ForAwaitStatement (async generator already added) [skip ci] (#196) (Henry Zhu)

6.13.0

October 21, 2016

:eyeglasses: Spec Compliancy

Property variance type annotations for Flow plugin (#161) (Sam Goldman)

See https://flowtype.org/docs/variance.html for more information

type T = { +p: T };
interface T { -p: T };
declare class T { +[k:K]: V };
class T { -[k:K]: V };
class C2 { +p: T = e };

Raise error on duplicate definition of proto (#183) (Moti Zilberman)

({ __proto__: 1, __proto__: 2 }) // Throws an error now

:bug: Bug Fix

Flow: Allow class properties to be named static (#184) (Moti Zilberman)

declare class A {
  static: T;
}

Allow "async" as identifier for object literal property shorthand (#187) (Andrew Levine)

var foo = { async, bar };

:nail_care: Polish

Fix flowtype and add inType to state (#189) (Daniel Tschinder)

This improves the performance slightly (because of hidden classes)

:house: Internal

Fix .gitattributes line ending setting (#191) (Moti Zilberman)

Increase test coverage (#175 (Moti Zilberman)

Readd missin .eslinignore for IDEs (Daniel Tschinder)

Error on missing expected.json fixture in CI (#188) (Moti Zilberman)

Add .gitattributes and .editorconfig for LF line endings (#179) (Moti Zilberman)

Fixes two tests that are failing after the merge of #172 (#177) (Moti Zilberman)

6.12.0

October 14, 2016

:eyeglasses: Spec Compliancy

Implement import() syntax (#163) (Jordan Gensler)

Dynamic Import

This repository contains a proposal for adding a "function-like" import() module loading syntactic form to JavaScript

import(`./section-modules/${link.dataset.entryModule}.js`)
.then(module => {
  module.loadPageInto(main);
})

Add EmptyTypeAnnotation (#171) (Sam Goldman)

EmptyTypeAnnotation

Just wasn't covered before.

type T = empty;

:bug: Bug Fix

Fix crash when exporting with destructuring and sparse array (#170) (Jeroen Engels)

// was failing due to sparse array
export const { foo: [ ,, qux7 ] } = bar;

Allow keyword in Flow object declaration property names with type parameters (#146) (Dan Harper)

declare class X {
  foobar<T>(): void;
  static foobar<T>(): void;
}

Allow keyword in object/class property names with Flow type parameters (#145) (Dan Harper)

class Foo {
  delete<T>(item: T): T {
    return item;
  }
}

Allow typeAnnotations for yield expressions (#174)) (Daniel Tschinder)

function *foo() {
  const x = (yield 5: any);
}

:nail_care: Polish

Annotate more errors with expected token (#172)) (Moti Zilberman)

// Unexpected token, expected ; (1:6)
{ set 1 }

:house: Internal

Remove kcheck (#173)) (Daniel Tschinder)

Also run flow, linting, babel tests on seperate instances (add back node 0.10)

6.11.6

October 12, 2016

:bug: Bug Fix/Regression

Fix crash when exporting with destructuring and sparse array (#170) (Jeroen Engels)

// was failing with `Cannot read property 'type' of null` because of null identifiers
export const { foo: [ ,, qux7 ] } = bar;

6.11.5

October 12, 2016

:eyeglasses: Spec Compliancy

Fix: Check for duplicate named exports in exported destructuring assignments (#144) (Kai Cataldo)

// `foo` has already been exported. Exported identifiers must be unique. (2:20)
export function foo() {};
export const { a: [{foo}] } = bar;

Fix: Check for duplicate named exports in exported rest elements/properties (#164) (Kai Cataldo)

// `foo` has already been exported. Exported identifiers must be unique. (2:22)
export const foo = 1;
export const [bar, ...foo] = baz;

:bug: Bug Fix

Fix: Allow identifier async for default param in arrow expression (#165) (Kai Cataldo)

// this is ok now
const test = ({async = true}) => {};

:nail_care: Polish

Babylon will now print out the token it's expecting if there's a SyntaxError (#150) (Daniel Tschinder)

# So in the case of a missing ending curly (`}`)
Module build failed: SyntaxError: Unexpected token, expected } (30:0)
  28 |   }
  29 |
> 30 |
     | ^

6.11.4

October 3, 2016

Temporary rollback for erroring on trailing comma with spread (#154) (Henry Zhu)

6.11.3

October 1, 2016

:eyeglasses: Spec Compliancy

Add static errors for object rest (#149) (@danez)

https://github.com/sebmarkbage/ecmascript-rest-spread

Object rest copies the rest of properties from the right hand side obj starting from the left to right.

let { x, y, ...z } =  { x: 1, y: 2, z: 3 };
// x = 1
// y = 2
// z = { z: 3 }

New Syntax Errors:

SyntaxError: The rest element has to be the last element when destructuring (1:10)

> 1 | let { ...x, y, z } = { x: 1, y: 2, z: 3};
    |           ^
# Previous behavior:
# x = { x: 1, y: 2, z: 3 }
# y = 2
# z = 3

Before, this was just a more verbose way of shallow copying obj since it doesn't actually do what you think.

SyntaxError: Cannot have multiple rest elements when destructuring (1:13)

> 1 | let { x, ...y, ...z } = { x: 1, y: 2, z: 3};
    |              ^
# Previous behavior:
# x = 1
# y = { y: 2, z: 3 }
# z = { y: 2, z: 3 }

Before y and z would just be the same value anyway so there is no reason to need to have both.

SyntaxError: A trailing comma is not permitted after the rest element (1:16)

let { x, y, ...z, } = obj;

The rationale for this is that the use case for trailing comma is that you can add something at the end without affecting the line above. Since a RestProperty always has to be the last property it doesn't make sense.

get / set are valid property names in default assignment (#142) (@jezell)

// valid
function something({ set = null, get = null }) {}

6.11.2

September 23, 2016

Bug Fix

  • #139 Don't do the duplicate check if not an identifier (#140) @hzoo
// regression with duplicate export check
SyntaxError: ./typography.js: `undefined` has already been exported. Exported identifiers must be unique. (22:13)
  20 | 
  21 | export const { rhythm } = typography;
> 22 | export const { TypographyStyle } = typography

Bail out for now, and make a change to account for destructuring in the next release.

6.11.1

September 22, 2016

Bug Fix

  • #137 - Fix a regression with duplicate exports - it was erroring on all keys in Object.prototype. @danez
export toString from './toString';
`toString` has already been exported. Exported identifiers must be unique. (1:7)
> 1 | export toString from './toString';
    |        ^
  2 |

6.11.0

September 22, 2016

Spec Compliancy (will break CI)

  • Disallow duplicate named exports (#107) @kaicataldo
// Only one default export allowed per module. (2:9)
export default function() {};
export { foo as default };

// Only one default export allowed per module. (2:0)
export default {};
export default function() {};

// `Foo` has already been exported. Exported identifiers must be unique. (2:0)
export { Foo };
export class Foo {};

New Feature (Syntax)

  • Add support for computed class property names (#121) @motiz88
// AST
interface ClassProperty <: Node {
  type: "ClassProperty";
  key: Identifier;
  value: Expression;
  computed: boolean; // added
}
// with "plugins": ["classProperties"]
class Foo {
  [x]
  ['y']
}

class Bar {
  [p]
  [m] () {}
}

Bug Fix

  • Fix static property falling through in the declare class Flow AST (#135) @danharper
declare class X {
    a: number;
    static b: number; // static
    c: number; // this was being marked as static in the AST as well
}

Polish

  • Rephrase "assigning/binding to rvalue" errors to include context (#119) @motiz88
// Used to error with:
// SyntaxError: Assigning to rvalue (1:0)

// Now:
// Invalid left-hand side in assignment expression (1:0)
3 = 4

// Invalid left-hand side in for-in statement (1:5)
for (+i in {});

Internal

  • Fix call to this.parseMaybeAssign with correct arguments (#133) @danez
  • Add semver note to changelog (#131) @hzoo

6.10.0

September 19, 2016

We plan to include some spec compliancy bugs in patch versions. An example was the multiple default exports issue.

Spec Compliancy

  • Implement ES2016 check for simple parameter list in strict mode (#106) (Timothy Gu)

It is a Syntax Error if ContainsUseStrict of FunctionBody is true and IsSimpleParameterList of FormalParameters is false. https://tc39.github.io/ecma262/2016/#sec-function-definitions-static-semantics-early-errors

More Context: tc39-notes

For example:

// this errors because it uses destructuring and default parameters
// in a function with a "use strict" directive
function a([ option1, option2 ] = []) {
  "use strict";
}

The solution would be to use a top level "use strict" or to remove the destructuring or default parameters when using a function + "use strict" or to.

New Feature

  • Exact object type annotations for Flow plugin (#104) (Basil Hosmer)

Added to flow in https://github.com/facebook/flow/commit/c710c40aa2a115435098d6c0dfeaadb023cd39b8

Looks like:

var a : {| x: number, y: string |} = { x: 0, y: 'foo' };

Bug Fixes

  • Include typeParameter location in ArrowFunctionExpression (#126) (Daniel Tschinder)
  • Error on invalid flow type annotation with default assignment (#122) (Dan Harper)
  • Fix Flow return types on arrow functions (#124) (Dan Harper)

Misc

  • Add tests for export extensions (#127) (Daniel Tschinder)
  • Fix Contributing guidelines [skip ci] (Daniel Tschinder)

6.9.2

September 9, 2016

The only change is to remove the babel-runtime dependency by compiling with Babel's ES2015 loose mode. So using babylon standalone should be smaller.

6.9.1

August 23, 2016

This release contains mainly small bugfixes but also updates babylons default mode to es2017. The features for exponentiationOperator, asyncFunctions and trailingFunctionCommas which previously needed to be activated via plugin are now enabled by default and the plugins are now no-ops.

Bug Fixes

  • Fix issues with default object params in async functions (#96) @danez
  • Fix issues with flow-types and async function (#95) @danez
  • Fix arrow functions with destructuring, types & default value (#94) @danharper
  • Fix declare class with qualified type identifier (#97) @danez
  • Remove exponentiationOperator, asyncFunctions, trailingFunctionCommas plugins and enable them by default (#98) @danez

6.9.0

August 16, 2016

New syntax support

  • Add JSX spread children (#42) @calebmer

(Be aware that React is not going to support this syntax)

<div>
  {...todos.map(todo => <Todo key={todo.id} todo={todo}/>)}
</div>
  • Add support for declare module.exports (#72) @danez
declare module "foo" {
  declare module.exports: {}
}

New Features

  • If supplied, attach filename property to comment node loc. (#80) @divmain
  • Add identifier name to node loc field (#90) @kittens

Bug Fixes

  • Fix exponential operator to behave according to spec (#75) @danez
  • Fix lookahead to not add comments to arrays which are not cloned (#76) @danez
  • Fix accidental fall-through in Flow type parsing. (#82) @xiemaisi
  • Only allow declares inside declare module (#73) @danez
  • Small fix for parsing type parameter declarations (#83) @gabelevi
  • Fix arrow param locations with flow types (#57) @danez
  • Fixes SyntaxError position with flow optional type (#65) @danez

Internal

  • Add codecoverage to tests @danez
  • Fix tests to not save expected output if we expect the test to fail @danez
  • Make a shallow clone of babel for testing @danez
  • chore(package): update cross-env to version 2.0.0 (#77) @greenkeeperio-bot
  • chore(package): update ava to version 0.16.0 (#86) @greenkeeperio-bot
  • chore(package): update babel-plugin-istanbul to version 2.0.0 (#89) @greenkeeperio-bot
  • chore(package): update nyc to version 8.0.0 (#88) @greenkeeperio-bot

6.8.4

July 6, 2016

Bug Fixes

  • Fix the location of params, when flow and default value used (#68) @danez

6.8.3

July 2, 2016

Bug Fixes

  • Fix performance regression introduced in 6.8.2 with conditionals (#63) @danez

6.8.2

June 24, 2016

Bug Fixes

  • Fix parse error with yielding jsx elements in generators function* it() { yield <a></a>; } (#31) @eldereal
  • When cloning nodes do not clone its comments (#24) @danez
  • Fix parse errors when using arrow functions with an spread element and return type (...props): void => {} (#10) @danez
  • Fix leading comments added from previous node (#23) @danez
  • Fix parse errors with flow's optional arguments (arg?) => {} (#19) @danez
  • Support negative numeric type literals @kittens
  • Remove line terminator restriction after await keyword @kittens
  • Remove grouped type arrow restriction as it seems flow no longer has it @kittens
  • Fix parse error with generic methods that have the name get or set class foo { get() {} } (#55) @vkurchatkin
  • Fix parse error with arrow functions that have flow type parameter declarations <T>(x: T): T => x; (#54) @gabelevi

Documentation

  • Document AST differences from ESTree (#41) @nene
  • Move ast spec from babel/babel (#46) @hzoo

Internal

  • Enable skipped tests (#16) @danez
  • Add script to test latest version of babylon with babel (#21) @danez
  • Upgrade test runner ava @kittens
  • Add missing generate-identifier-regex script @kittens
  • Rename parser context types @kittens
  • Add node v6 to travis testing @hzoo
  • Update to Unicode v9 (#45) @mathiasbynens

6.8.1

June 6, 2016

New Feature

  • Parse type parameter declarations with defaults like type Foo<T = string> = T

Bug Fixes

  • Type parameter declarations need 1 or more type parameters.
  • The existential type * is not a valid type parameter.
  • The existential type * is a primary type

Spec Compliancy

  • The param list for type parameter declarations now consists of TypeParameter nodes
  • New TypeParameter AST Node (replaces using the Identifier node before)
interface TypeParameter <: Node {
  bound: TypeAnnotation;
  default: TypeAnnotation;
  name: string;
  variance: "plus" | "minus";
}

6.8.0

May 2, 2016

New Feature

Parse Method Parameter Decorators (#12)

Method Parameter Decorators is now a TC39 stage 0 proposal.

Examples:

class Foo {
  constructor(@foo() x, @bar({ a: 123 }) @baz() y) {}
}

export default function func(@foo() x, @bar({ a: 123 }) @baz() y) {}

var obj = {
  method(@foo() x, @bar({ a: 123 }) @baz() y) {}
};

Parse for-await statements (w/ asyncGenerators plugin) (#17)

There is also a new node type, ForAwaitStatement.

Async generators and for-await are now a stage 2 proposal.

Example:

async function f() {
  for await (let x of y);
}