ast-types-flow

Flow types for the Javascript AST. Based off of benjamn/ast-types.

Usage

First install ast-types-flow via npm, then you can import any of the types that are exported.

```javascript / @flow /

import type {Node} from 'ast-types-flow';

function getName(node: Node): string { switch (node.type) { case 'Identifier': return node.name;

case 'ClassDeclaration':
  return node.id.name; // Error, id could be null.

case 'FunctionDeclaration':
  return node.id.name; // Fine if it's always there.

case 'FunctionExpression':
  if (node.id) {
    return node.id.name; // Can refine id to make sure it exists.
  } else {
    return 'Unknown';
  }

case 'Literal':
  return node.name; // Error, Literals don't have names, don't be silly.

} return 'Unknown'; } ```

How it works

A notion of "extends" is added to the Flow syntax via comments. A transform is included that will compile the source code into useful disjoint union types based on how the different types extend each other. For example:

```javascript type Node = { common: string, };

type Foo = { // extends Node foo: string, };

type Bar = { // extends Node bar: number, }; ```

Will be transformed into:

```javascript type Node = { type: 'Foo', _Foo: void, common: string, foo: string, } | { type: 'Bar', _Bar: void, common: string, bar: number, };

type Foo = { type: 'Foo', _Foo: void, common: string, foo: string, };

type Bar = { type: 'Bar', _Foo: void, common: string, bar: number, }; ```

A few things to note:

The type Node would more ideally be compiled into Foo | Bar but then the disjoint union cannot be properly refined. For now we have to duplicate the complete definitions.
Each entry in a disjoint union has to be structurally unique or Flow will have an error on the definition. That is why the private _Foo: void fields appear in the types.