100 lines
2.0 KiB
Plaintext
100 lines
2.0 KiB
Plaintext
# ast-types-flow
|
|
|
|
Flow types for the Javascript AST. Based off of [benjamn/ast-types](https://github.com/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:
|
|
|
|
1. 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.
|
|
2. 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.
|