module ast-types
1. function ast-types.NodePath (value, parentPath, name)
2. function ast-types.Path (value, parentPath, name)
3. function ast-types.PathVisitor ()
4. function ast-types.Type (check, name)
5. function ast-types.astNodesAreEquivalent (a, b, problemPath)
6. function ast-types.defineMethod (name, func)
7. function ast-types.eachField (object, callback, context)
8. function ast-types.finalize ()
9. function ast-types.getFieldNames (object)
10. function ast-types.getFieldValue (object, fieldName)
11. function ast-types.getSupertypeNames (typeName)
12. function ast-types.someField (object, callback, context)
13. function ast-types.use (plugin)
14. function ast-types.visit (node, methods)
15. object ast-types.NodePath.prototype
16. object ast-types.Path.prototype
17. object ast-types.PathVisitor.prototype
18. object ast-types.Type.prototype
19. object ast-types.builders
20. object ast-types.builtInTypes
21. object ast-types.namedTypes
module ast-types.NodePath
1. function ast-types.NodePath (value, parentPath, name)
module ast-types.NodePath.prototype
module ast-types.Path
1. function ast-types.Path (value, parentPath, name)
module ast-types.Path.prototype
module ast-types.PathVisitor
module ast-types.PathVisitor.prototype
module ast-types.Type
module ast-types.Type.prototype
module ast-types.astNodesAreEquivalent
1. function ast-types.astNodesAreEquivalent (a, b, problemPath)
2. function ast-types.astNodesAreEquivalent.assert (a, b)
module ast-types.builders

module ast-types

function ast-types.NodePath (value, parentPath, name)

description and source-code

function NodePath(value, parentPath, name) {
    if (!(this instanceof NodePath)) {
        throw new Error("NodePath constructor cannot be invoked without 'new'");
    }
    Path.call(this, value, parentPath, name);
}

example usage
```
n/a
```

function ast-types.Path (value, parentPath, name)

description and source-code

function Path(value, parentPath, name) {
    if (!(this instanceof Path)) {
        throw new Error("Path constructor cannot be invoked without 'new'");
    }

    if (parentPath) {
        if (!(parentPath instanceof Path)) {
            throw new Error("");
        }
    } else {
        parentPath = null;
        name = null;
    }

    // The value encapsulated by this Path, generally equal to
    // parentPath.value[name] if we have a parentPath.
    this.value = value;

    // The immediate parent Path of this Path.
    this.parentPath = parentPath;

    // The name of the property of parentPath.value through which this
    // Path's value was reached.
    this.name = name;

    // Calling path.get("child") multiple times always returns the same
    // child Path object, for both performance and consistency reasons.
    this.__childCache = null;
}

example usage
```
n/a
```

function ast-types.PathVisitor ()

description and source-code

function PathVisitor() {
    if (!(this instanceof PathVisitor)) {
        throw new Error(
          "PathVisitor constructor cannot be invoked without 'new'"
        );
    }

    // Permanent state.
    this._reusableContextStack = [];

    this._methodNameTable = computeMethodNameTable(this);
    this._shouldVisitComments =
      hasOwn.call(this._methodNameTable, "Block") ||
      hasOwn.call(this._methodNameTable, "Line");

    this.Context = makeContextConstructor(this);

    // State reset every time PathVisitor.prototype.visit is called.
    this._visiting = false;
    this._changeReported = false;
}

example usage
```
n/a
```

function ast-types.Type (check, name)

description and source-code

function Type(check, name) {
    var self = this;
    if (!(self instanceof Type)) {
        throw new Error("Type constructor cannot be invoked without 'new'");
    }

    // Unfortunately we can't elegantly reuse isFunction and isString,
    // here, because this code is executed while defining those types.
    if (objToStr.call(check) !== funObjStr) {
        throw new Error(check + " is not a function");
    }

    // The `name` parameter can be either a function or a string.
    var nameObjStr = objToStr.call(name);
    if (!(nameObjStr === funObjStr ||
      nameObjStr === strObjStr)) {
        throw new Error(name + " is neither a function nor a string");
    }

    Object.defineProperties(self, {
        name: {value: name},
        check: {
            value: function (value, deep) {
                var result = check.call(self, value, deep);
                if (!result && deep && objToStr.call(deep) === funObjStr)
                    deep(self, value);
                return result;
            }
        }
    });
}

example usage
```
n/a
```

function ast-types.astNodesAreEquivalent (a, b, problemPath)

description and source-code

function astNodesAreEquivalent(a, b, problemPath) {
    if (isArray.check(problemPath)) {
        problemPath.length = 0;
    } else {
        problemPath = null;
    }

    return areEquivalent(a, b, problemPath);
}

example usage
```
n/a
```

function ast-types.defineMethod (name, func)

description and source-code

defineMethod = function (name, func) {
    var old = nodePrototype[name];

    // Pass undefined as func to delete nodePrototype[name].
    if (isUndefined.check(func)) {
        delete nodePrototype[name];

    } else {
        isFunction.assert(func);

        Object.defineProperty(nodePrototype, name, {
            enumerable: true, // For discoverability.
            configurable: true, // For delete proto[name].
            value: func
        });
    }

    return old;
}

example usage
```
n/a
```

function ast-types.eachField (object, callback, context)

description and source-code

eachField = function (object, callback, context) {
    getFieldNames(object).forEach(function (name) {
        callback.call(this, name, getFieldValue(object, name));
    }, context);
}

example usage

...
    }, context);
};
```

So here's how you might make a copy of an AST node:
```js
var copy = {};
require("ast-types").eachField(node, function(name, value) {
    // Note that undefined fields will be visited too, according to
    // the rules associated with node.type, and default field values
    // will be substituted if appropriate.
    copy[name] = value;
})
```
...

function ast-types.finalize ()

description and source-code

finalize = function () {
    Object.keys(defCache).forEach(function (name) {
        defCache[name].finalize();
    });
}

example usage

...
.bases("Node")
.build("name", "program")
.field("name", string)
.field("program", def("Program"));

// Prevent further modifications to the File type (and any other
// types newly introduced by def(...)).
types.finalize();

// The b.file builder function is now available. It expects two
// arguments, as named by .build("name", "program") above.
var main = b.file("main.js", b.program([
// Pointless program contents included for extra color.
b.functionDeclaration(b.identifier("succ"), [
    b.identifier("x")
...

function ast-types.getFieldNames (object)

description and source-code

function getFieldNames(object) {
    var d = Def.fromValue(object);
    if (d) {
        return d.fieldNames.slice(0);
    }

    if ("type" in object) {
        throw new Error(
          "did not recognize object of type " +
          JSON.stringify(object.type)
        );
    }

    return Object.keys(object);
}

example usage

...
`getFieldValue`:
```js
var types = require("ast-types");
var partialFunExpr = { type: "FunctionExpression" };

// Even though partialFunExpr doesn't actually contain all the fields that
// are expected for a FunctionExpression, types.getFieldNames knows:
console.log(types.getFieldNames(partialFunExpr));
// [ 'type', 'id', 'params', 'body', 'generator', 'expression',
//   'defaults', 'rest', 'async' ]

// For fields that have default values, types.getFieldValue will return
// the default if the field is not actually defined.
console.log(types.getFieldValue(partialFunExpr, "generator"));
// false
...

function ast-types.getFieldValue (object, fieldName)

description and source-code

function getFieldValue(object, fieldName) {
    var d = Def.fromValue(object);
    if (d) {
        var field = d.allFields[fieldName];
        if (field) {
            return field.getValue(object);
        }
    }

    return object && object[fieldName];
}

example usage

...
// are expected for a FunctionExpression, types.getFieldNames knows:
console.log(types.getFieldNames(partialFunExpr));
// [ 'type', 'id', 'params', 'body', 'generator', 'expression',
//   'defaults', 'rest', 'async' ]

// For fields that have default values, types.getFieldValue will return
// the default if the field is not actually defined.
console.log(types.getFieldValue(partialFunExpr, "generator"));
// false
```

Two more low-level helper functions, `eachField` and `someField`, are
defined in terms of `getFieldNames` and `getFieldValue`:
```js
// Iterate over all defined fields of an object, including those missing
...

function ast-types.getSupertypeNames (typeName)

description and source-code

getSupertypeNames = function (typeName) {
    if (!hasOwn.call(defCache, typeName)) {
        throw new Error("");
    }
    var d = defCache[typeName];
    if (d.finalized !== true) {
        throw new Error("");
    }
    return d.supertypeList.slice(1);
}

example usage
```
n/a
```

function ast-types.someField (object, callback, context)

description and source-code

someField = function (object, callback, context) {
    return getFieldNames(object).some(function (name) {
        return callback.call(this, name, getFieldValue(object, name));
    }, context);
}

example usage

...
    }

    if (isArray.check(node)) {
        return node.some(containsCallExpression);
    }

    if (n.Node.check(node)) {
        return types.someField(node, function (name, child) {
            return containsCallExpression(child);
        });
    }

    return false;
}
...

function ast-types.use (plugin)

description and source-code

function use(plugin) {
    var idx = used.indexOf(plugin);
    if (idx === -1) {
        idx = used.length;
        used.push(plugin);
        usedResult[idx] = plugin(fork);
    }
    return usedResult[idx];
}

example usage

...






module.exports = function (fork) {
fork.use(require("./es7"));

var types = fork.use(require("../lib/types"));
var defaults = fork.use(require("../lib/shared")).defaults;
var def = types.Type.def;
var or = types.Type.or;

def("Noop")
...

function ast-types.visit (node, methods)

description and source-code

function visit(node, methods) {
    return PathVisitor.fromMethodsObject(methods).visit(node);
}

example usage

...
Here's a trivial example of how you might assert that `arguments.callee`
is never used in `ast`:
```js
var assert = require("assert");
var types = require("ast-types");
var n = types.namedTypes;

types.visit(ast, {
    // This method will be called for any node with .type "MemberExpression":
    visitMemberExpression: function(path) {
// Visitor methods receive a single argument, a NodePath object
// wrapping the node of interest.
var node = path.node;

if (n.Identifier.check(node.object) &&
...

module ast-types.NodePath

function ast-types.NodePath (value, parentPath, name)

description and source-code

function NodePath(value, parentPath, name) {
    if (!(this instanceof NodePath)) {
        throw new Error("NodePath constructor cannot be invoked without 'new'");
    }
    Path.call(this, value, parentPath, name);
}

example usage
```
n/a
```

module ast-types.NodePath.prototype

function ast-types.NodePath.prototype._computeNode ()

description and source-code

_computeNode = function () {
    var value = this.value;
    if (n.Node.check(value)) {
        return value;
    }

    var pp = this.parentPath;
    return pp && pp.node || null;
}

example usage

...
    });

    Object.defineProperties(NPp, {
node: {
    get: function () {
        Object.defineProperty(this, "node", {
            configurable: true, // Enable deletion.
            value: this._computeNode()
        });

        return this.node;
    }
},

parent: {
...

function ast-types.NodePath.prototype._computeParent ()

description and source-code

_computeParent = function () {
    var value = this.value;
    var pp = this.parentPath;

    if (!n.Node.check(value)) {
        while (pp && !n.Node.check(pp.value)) {
            pp = pp.parentPath;
        }

        if (pp) {
            pp = pp.parentPath;
        }
    }

    while (pp && !n.Node.check(pp.value)) {
        pp = pp.parentPath;
    }

    return pp || null;
}

example usage

...
    }
},

parent: {
    get: function () {
        Object.defineProperty(this, "parent", {
            configurable: true, // Enable deletion.
            value: this._computeParent()
        });

        return this.parent;
    }
},

scope: {
...

function ast-types.NodePath.prototype._computeScope ()

description and source-code

_computeScope = function () {
    var value = this.value;
    var pp = this.parentPath;
    var scope = pp && pp.scope;

    if (n.Node.check(value) &&
      Scope.isEstablishedBy(value)) {
        scope = new Scope(this, scope);
    }

    return scope || null;
}

example usage

...
        }
    },

    scope: {
        get: function () {
            Object.defineProperty(this, "scope", {
                configurable: true, // Enable deletion.
                value: this._computeScope()
            });

            return this.scope;
        }
    }
});
...

function ast-types.NodePath.prototype.canBeFirstInStatement ()

description and source-code

canBeFirstInStatement = function () {
    var node = this.node;
    return !n.FunctionExpression.check(node)
      && !n.ObjectExpression.check(node);
}

example usage

...
              this.name === "callee" &&
              parent.callee === node) {
                return containsCallExpression(node);
            }
    }

    if (assumeExpressionContext !== true &&
      !this.canBeFirstInStatement() &&
      this.firstInStatement())
        return true;

    return false;
};

function isBinary(node) {
...

function ast-types.NodePath.prototype.firstInStatement ()

description and source-code

firstInStatement = function () {
    return firstInStatement(this);
}

example usage

...
              parent.callee === node) {
                return containsCallExpression(node);
            }
    }

    if (assumeExpressionContext !== true &&
      !this.canBeFirstInStatement() &&
      this.firstInStatement())
        return true;

    return false;
};

function isBinary(node) {
    return n.BinaryExpression.check(node)
...

function ast-types.NodePath.prototype.getValueProperty (name)

description and source-code

getValueProperty = function (name) {
    return types.getFieldValue(this.value, name);
}

example usage

...
    // Lazily create the child cache. This also cheapens cache
    // invalidation, since you can just reset path.__childCache to null.
    return path.__childCache || (path.__childCache = Object.create(null));
}

function getChildPath(path, name) {
    var cache = getChildCache(path);
    var actualChildValue = path.getValueProperty(name);
    var childPath = cache[name];
    if (!hasOwn.call(cache, name) ||
      // Ensure consistency between cache and reality.
      childPath.value !== actualChildValue) {
        childPath = cache[name] = new path.constructor(
          actualChildValue, path, name
        );
...

function ast-types.NodePath.prototype.needsParens (assumeExpressionContext)

description and source-code

needsParens = function (assumeExpressionContext) {
    var pp = this.parentPath;
    if (!pp) {
        return false;
    }

    var node = this.value;

    // Only expressions need parentheses.
    if (!n.Expression.check(node)) {
        return false;
    }

    // Identifiers never need parentheses.
    if (node.type === "Identifier") {
        return false;
    }

    while (!n.Node.check(pp.value)) {
        pp = pp.parentPath;
        if (!pp) {
            return false;
        }
    }

    var parent = pp.value;

    switch (node.type) {
        case "UnaryExpression":
        case "SpreadElement":
        case "SpreadProperty":
            return parent.type === "MemberExpression"
              && this.name === "object"
              && parent.object === node;

        case "BinaryExpression":
        case "LogicalExpression":
            switch (parent.type) {
                case "CallExpression":
                    return this.name === "callee"
                      && parent.callee === node;

                case "UnaryExpression":
                case "SpreadElement":
                case "SpreadProperty":
                    return true;

                case "MemberExpression":
                    return this.name === "object"
                      && parent.object === node;

                case "BinaryExpression":
                case "LogicalExpression":
                    var po = parent.operator;
                    var pp = PRECEDENCE[po];
                    var no = node.operator;
                    var np = PRECEDENCE[no];

                    if (pp > np) {
                        return true;
                    }

                    if (pp === np && this.name === "right") {
                        if (parent.right !== node) {
                            throw new Error("Nodes must be equal");
                        }
                        return true;
                    }

                default:
                    return false;
            }

        case "SequenceExpression":
            switch (parent.type) {
                case "ForStatement":
                    // Although parentheses wouldn't hurt around sequence
                    // expressions in the head of for loops, traditional style
                    // dictates that e.g. i++, j++ should not be wrapped with
                    // parentheses.
                    return false;

                case "ExpressionStatement":
                    return this.name !== "expression";

                default:
                    // Otherwise err on the side of overparenthesization, adding
                    // explicit exceptions above if this proves overzealous.
                    return true;
            }

        case "YieldExpression":
            switch (parent.type) {
                case "BinaryExpression":
                case "LogicalExpression":
                case "UnaryExpression":
                case "SpreadElement":
                case "SpreadProperty":
                case "CallExpression":
                case "MemberExpression":
                case "NewExpression":
                case "ConditionalExpression":
                case "YieldExpression":
                    return true;

                default:
                    return false;
            }

        case "Literal":
            return parent.type === "MemberExpression"
              && isNumber.check(node.value)
              && this.name === "object"
              && parent.object === node;

        case "AssignmentExpression":
        case "ConditionalExpression":
            switch (parent.type) {
                case "UnaryExpression":
                case "SpreadElement":
                case "SpreadProperty":
                case "BinaryExpression":
                case "LogicalExpression":
                    return true;

                case "CallExpression":
                    return this.name === "callee"
                      && parent.callee === node;

                case "ConditionalExpression":
                    return this.name === " ...

example usage
```
n/a
```

function ast-types.NodePath.prototype.prune ()

description and source-code

prune = function () {
    var remainingNodePath = this.parent;

    this.replace();

    return cleanUpNodesAfterPrune(remainingNodePath);
}

example usage

...
path.get("elements", 2).replace(
    b.identifier("foo"),
    b.thisExpression()
);

// Remove a node and its parent if it would leave a redundant AST node:
//e.g. var t = 1, y =2; removing the `t` and `y` declarators results in `var undefined`.
path.prune(); //returns the closest parent `NodePath`.

// Remove a node from a list of nodes:
path.get("elements", 3).replace();

// Add three new nodes to the beginning of a list of nodes:
path.get("elements").unshift(a, b, c);
...

function ast-types.NodePath.prototype.replace ()

description and source-code

replace = function () {
    delete this.node;
    delete this.parent;
    delete this.scope;
    return Path.prototype.replace.apply(this, arguments);
}

example usage

...
        // Similar to doing node.body.body.unshift(restVarDecl), except
        // that the other NodePath objects wrapping body statements will
        // have their indexes updated to accommodate the new statement.
        path.get("body", "body").unshift(restVarDecl);

        // Nullify node.rest now that we have simulated the behavior of
        // the rest parameter using ordinary JavaScript.
        path.get("rest").replace(null);

        // There's nothing wrong with doing node.rest = null, but I wanted
        // to point out that the above statement has the same effect.
        assert.strictEqual(node.rest, null);
    }
});
```
...

module ast-types.Path

function ast-types.Path (value, parentPath, name)

description and source-code

function Path(value, parentPath, name) {
    if (!(this instanceof Path)) {
        throw new Error("Path constructor cannot be invoked without 'new'");
    }

    if (parentPath) {
        if (!(parentPath instanceof Path)) {
            throw new Error("");
        }
    } else {
        parentPath = null;
        name = null;
    }

    // The value encapsulated by this Path, generally equal to
    // parentPath.value[name] if we have a parentPath.
    this.value = value;

    // The immediate parent Path of this Path.
    this.parentPath = parentPath;

    // The name of the property of parentPath.value through which this
    // Path's value was reached.
    this.name = name;

    // Calling path.get("child") multiple times always returns the same
    // child Path object, for both performance and consistency reasons.
    this.__childCache = null;
}

example usage
```
n/a
```

module ast-types.Path.prototype

function ast-types.Path.prototype.each (callback, context)

description and source-code

function each(callback, context) {
    var childPaths = [];
    var len = this.value.length;
    var i = 0;

    // Collect all the original child paths before invoking the callback.
    for (var i = 0; i < len; ++i) {
        if (hasOwn.call(this.value, i)) {
            childPaths[i] = this.get(i);
        }
    }

    // Invoke the callback on just the original child paths, regardless of
    // any modifications made to the array by the callback. I chose these
    // semantics over cleverly invoking the callback on new elements because
    // this way is much easier to reason about.
    context = context || this;
    for (i = 0; i < len; ++i) {
        if (hasOwn.call(childPaths, i)) {
            callback.call(context, childPaths[i]);
        }
    }
}

example usage

...
        if (!(visitor instanceof PathVisitor)) {
throw new Error("");
        }

        var value = path.value;

        if (isArray.check(value)) {
path.each(visitor.visitWithoutReset, visitor);
        } else if (!isObject.check(value)) {
// No children to visit.
        } else {
var childNames = types.getFieldNames(value);

// The .comments field of the Node type is hidden, so we only
// visit it if the visitor defines visitBlock or visitLine, and
...

function ast-types.Path.prototype.filter (callback, context)

description and source-code

function filter(callback, context) {
    var result = [];

    this.each(function (childPath) {
        if (callback.call(this, childPath)) {
            result.push(childPath);
        }
    }, context);

    return result;
}

example usage
```
n/a
```

function ast-types.Path.prototype.get (name)

description and source-code

function get(name) {
    var path = this;
    var names = arguments;
    var count = names.length;

    for (var i = 0; i < count; ++i) {
        path = getChildPath(path, names[i]);
    }

    return path;
}

example usage

...
        ])
    )
]);

// Similar to doing node.body.body.unshift(restVarDecl), except
// that the other NodePath objects wrapping body statements will
// have their indexes updated to accommodate the new statement.
path.get("body", "body").unshift(restVarDecl);

// Nullify node.rest now that we have simulated the behavior of
// the rest parameter using ordinary JavaScript.
path.get("rest").replace(null);

// There's nothing wrong with doing node.rest = null, but I wanted
// to point out that the above statement has the same effect.
...

function ast-types.Path.prototype.getValueProperty (name)

description and source-code

function getValueProperty(name) {
    return this.value[name];
}

example usage

...
    // Lazily create the child cache. This also cheapens cache
    // invalidation, since you can just reset path.__childCache to null.
    return path.__childCache || (path.__childCache = Object.create(null));
}

function getChildPath(path, name) {
    var cache = getChildCache(path);
    var actualChildValue = path.getValueProperty(name);
    var childPath = cache[name];
    if (!hasOwn.call(cache, name) ||
      // Ensure consistency between cache and reality.
      childPath.value !== actualChildValue) {
        childPath = cache[name] = new path.constructor(
          actualChildValue, path, name
        );
...

function ast-types.Path.prototype.insertAfter (node)

description and source-code

function insertAfter(node) {
    var pp = this.parentPath;
    var argc = arguments.length;
    var insertAtArgs = [this.name + 1];
    for (var i = 0; i < argc; ++i) {
        insertAtArgs.push(arguments[i]);
    }
    return pp.insertAt.apply(pp, insertAtArgs);
}

example usage

...

// Remove and return the last node in a list of nodes:
path.get("elements").pop();

// Insert a new node before/after the seventh node in a list of nodes:
var seventh = path.get("elements", 6);
seventh.insertBefore(newNode);
seventh.insertAfter(newNode);

// Insert a new element at index 5 in a list of nodes:
path.get("elements").insertAt(5, newNode);
```

Scope
---
...

function ast-types.Path.prototype.insertAt (index, node)

description and source-code

function insertAt(index, node) {
    var argc = arguments.length;
    var move = getMoves(this, argc - 1, index);
    if (move === emptyMoves) {
        return this;
    }

    index = Math.max(index, 0);

    for (var i = 1; i < argc; ++i) {
        this.value[index + i - 1] = arguments[i];
    }

    move();

    return this;
}

example usage

...

// Insert a new node before/after the seventh node in a list of nodes:
var seventh = path.get("elements", 6);
seventh.insertBefore(newNode);
seventh.insertAfter(newNode);

// Insert a new element at index 5 in a list of nodes:
path.get("elements").insertAt(5, newNode);
```

Scope
---

The object exposed as `path.scope` during AST traversals provides
information about variable and function declarations in the scope that
...

function ast-types.Path.prototype.insertBefore (node)

description and source-code

function insertBefore(node) {
    var pp = this.parentPath;
    var argc = arguments.length;
    var insertAtArgs = [this.name];
    for (var i = 0; i < argc; ++i) {
        insertAtArgs.push(arguments[i]);
    }
    return pp.insertAt.apply(pp, insertAtArgs);
}

example usage

...
path.get("elements").push(d, e);

// Remove and return the last node in a list of nodes:
path.get("elements").pop();

// Insert a new node before/after the seventh node in a list of nodes:
var seventh = path.get("elements", 6);
seventh.insertBefore(newNode);
seventh.insertAfter(newNode);

// Insert a new element at index 5 in a list of nodes:
path.get("elements").insertAt(5, newNode);
```

Scope
...

function ast-types.Path.prototype.map (callback, context)

description and source-code

function map(callback, context) {
    var result = [];

    this.each(function (childPath) {
        result.push(callback.call(this, childPath));
    }, context);

    return result;
}

example usage

...
        if (problemPath.length === 0) {
            if (a !== b) {
                throw new Error("Nodes must be equal");
            }
        } else {
            throw new Error(
              "Nodes differ in the following path: " +
              problemPath.map(subscriptForProperty).join("")
            );
        }
    }
};

function subscriptForProperty(property) {
    if (/[_$a-z][_$a-z0-9]*/i.test(property)) {
...

function ast-types.Path.prototype.pop ()

description and source-code

function pop() {
    isArray.assert(this.value);
    var cache = getChildCache(this);
    delete cache[this.value.length - 1];
    delete cache.length;
    return this.value.pop();
}

example usage

...
// Remove and return the first node in a list of nodes:
path.get("elements").shift();

// Push two new nodes onto the end of a list of nodes:
path.get("elements").push(d, e);

// Remove and return the last node in a list of nodes:
path.get("elements").pop();

// Insert a new node before/after the seventh node in a list of nodes:
var seventh = path.get("elements", 6);
seventh.insertBefore(newNode);
seventh.insertAfter(newNode);

// Insert a new element at index 5 in a list of nodes:
...

function ast-types.Path.prototype.push (node)

description and source-code

function push(node) {
    isArray.assert(this.value);
    delete getChildCache(this).length
    return this.value.push.apply(this.value, arguments);
}

example usage

...
// Add three new nodes to the beginning of a list of nodes:
path.get("elements").unshift(a, b, c);

// Remove and return the first node in a list of nodes:
path.get("elements").shift();

// Push two new nodes onto the end of a list of nodes:
path.get("elements").push(d, e);

// Remove and return the last node in a list of nodes:
path.get("elements").pop();

// Insert a new node before/after the seventh node in a list of nodes:
var seventh = path.get("elements", 6);
seventh.insertBefore(newNode);
...

function ast-types.Path.prototype.replace (replacement)

description and source-code

function replace(replacement) {
    var results = [];
    var parentValue = this.parentPath.value;
    var parentCache = getChildCache(this.parentPath);
    var count = arguments.length;

    repairRelationshipWithParent(this);

    if (isArray.check(parentValue)) {
        var originalLength = parentValue.length;
        var move = getMoves(this.parentPath, count - 1, this.name + 1);

        var spliceArgs = [this.name, 1];
        for (var i = 0; i < count; ++i) {
            spliceArgs.push(arguments[i]);
        }

        var splicedOut = parentValue.splice.apply(parentValue, spliceArgs);

        if (splicedOut[0] !== this.value) {
            throw new Error("");
        }
        if (parentValue.length !== (originalLength - 1 + count)) {
            throw new Error("");
        }

        move();

        if (count === 0) {
            delete this.value;
            delete parentCache[this.name];
            this.__childCache = null;

        } else {
            if (parentValue[this.name] !== replacement) {
                throw new Error("");
            }

            if (this.value !== replacement) {
                this.value = replacement;
                this.__childCache = null;
            }

            for (i = 0; i < count; ++i) {
                results.push(this.parentPath.get(this.name + i));
            }

            if (results[0] !== this) {
                throw new Error("");
            }
        }

    } else if (count === 1) {
        if (this.value !== replacement) {
            this.__childCache = null;
        }
        this.value = parentValue[this.name] = replacement;
        results.push(this);

    } else if (count === 0) {
        delete parentValue[this.name];
        delete this.value;
        this.__childCache = null;

        // Leave this path cached as parentCache[this.name], even though
        // it no longer has a value defined.

    } else {
        throw new Error("Could not replace path");
    }

    return results;
}

example usage

...
        // Similar to doing node.body.body.unshift(restVarDecl), except
        // that the other NodePath objects wrapping body statements will
        // have their indexes updated to accommodate the new statement.
        path.get("body", "body").unshift(restVarDecl);

        // Nullify node.rest now that we have simulated the behavior of
        // the rest parameter using ordinary JavaScript.
        path.get("rest").replace(null);

        // There's nothing wrong with doing node.rest = null, but I wanted
        // to point out that the above statement has the same effect.
        assert.strictEqual(node.rest, null);
    }
});
```
...

function ast-types.Path.prototype.shift ()

description and source-code

function shift() {
    var move = getMoves(this, -1);
    var result = this.value.shift();
    move();
    return result;
}

example usage

...
// Remove a node from a list of nodes:
path.get("elements", 3).replace();

// Add three new nodes to the beginning of a list of nodes:
path.get("elements").unshift(a, b, c);

// Remove and return the first node in a list of nodes:
path.get("elements").shift();

// Push two new nodes onto the end of a list of nodes:
path.get("elements").push(d, e);

// Remove and return the last node in a list of nodes:
path.get("elements").pop();
...

function ast-types.Path.prototype.unshift (node)

description and source-code

function unshift(node) {
    var move = getMoves(this, arguments.length);
    var result = this.value.unshift.apply(this.value, arguments);
    move();
    return result;
}

example usage

...
        b.callExpression(sliceExpr, [
            b.identifier("arguments"),
            b.literal(node.params.length)
        ])
    )
]);

// Similar to doing node.body.body.unshift(restVarDecl), except
// that the other NodePath objects wrapping body statements will
// have their indexes updated to accommodate the new statement.
path.get("body", "body").unshift(restVarDecl);

// Nullify node.rest now that we have simulated the behavior of
// the rest parameter using ordinary JavaScript.
path.get("rest").replace(null);
...

module ast-types.PathVisitor

function ast-types.PathVisitor ()

description and source-code

function PathVisitor() {
    if (!(this instanceof PathVisitor)) {
        throw new Error(
          "PathVisitor constructor cannot be invoked without 'new'"
        );
    }

    // Permanent state.
    this._reusableContextStack = [];

    this._methodNameTable = computeMethodNameTable(this);
    this._shouldVisitComments =
      hasOwn.call(this._methodNameTable, "Block") ||
      hasOwn.call(this._methodNameTable, "Line");

    this.Context = makeContextConstructor(this);

    // State reset every time PathVisitor.prototype.visit is called.
    this._visiting = false;
    this._changeReported = false;
}

example usage
```
n/a
```

function ast-types.PathVisitor.fromMethodsObject (methods)

description and source-code

function fromMethodsObject(methods) {
    if (methods instanceof PathVisitor) {
        return methods;
    }

    if (!isObject.check(methods)) {
        // An empty visitor?
        return new PathVisitor;
    }

    function Visitor() {
        if (!(this instanceof Visitor)) {
            throw new Error(
              "Visitor constructor cannot be invoked without 'new'"
            );
        }
        PathVisitor.call(this);
    }

    var Vp = Visitor.prototype = Object.create(PVp);
    Vp.constructor = Visitor;

    extend(Vp, methods);
    extend(Visitor, PathVisitor);

    isFunction.assert(Visitor.fromMethodsObject);
    isFunction.assert(Visitor.visit);

    return new Visitor;
}

example usage

...
        }
    }

    return target;
}

PathVisitor.visit = function visit(node, methods) {
    return PathVisitor.fromMethodsObject(methods).visit(node);
};

var PVp = PathVisitor.prototype;

PVp.visit = function () {
    if (this._visiting) {
        throw new Error(
...

function ast-types.PathVisitor.visit (node, methods)

description and source-code

function visit(node, methods) {
    return PathVisitor.fromMethodsObject(methods).visit(node);
}

example usage

...
Here's a trivial example of how you might assert that `arguments.callee`
is never used in `ast`:
```js
var assert = require("assert");
var types = require("ast-types");
var n = types.namedTypes;

types.visit(ast, {
    // This method will be called for any node with .type "MemberExpression":
    visitMemberExpression: function(path) {
// Visitor methods receive a single argument, a NodePath object
// wrapping the node of interest.
var node = path.node;

if (n.Identifier.check(node.object) &&
...

module ast-types.PathVisitor.prototype

function ast-types.PathVisitor.prototype.AbortRequest ()

description and source-code
```
function AbortRequest() {}
```

example usage

...
return root;
    };

    PVp.AbortRequest = function AbortRequest() {};
    PVp.abort = function () {
var visitor = this;
visitor._abortRequested = true;
var request = new visitor.AbortRequest();

// If you decide to catch this exception and stop it from propagating,
// make sure to call its cancel method to avoid silencing other
// exceptions that might be thrown later in the traversal.
request.cancel = function () {
    visitor._abortRequested = false;
};
...

function ast-types.PathVisitor.prototype.abort ()

description and source-code

abort = function () {
    var visitor = this;
    visitor._abortRequested = true;
    var request = new visitor.AbortRequest();

    // If you decide to catch this exception and stop it from propagating,
    // make sure to call its cancel method to avoid silencing other
    // exceptions that might be thrown later in the traversal.
    request.cancel = function () {
        visitor._abortRequested = false;
    };

    throw request;
}

example usage

...
    var result = false;

    types.visit(funcNode, {
visitThisExpression: function(path) {
    result = true;

    // The quickest way to terminate the traversal is to call
    // this.abort(), which throws a special exception (instanceof
    // this.AbortRequest) that will be caught in the top-level
    // types.visit method, so you don't have to worry about
    // catching the exception yourself.
    this.abort();
},

visitFunction: function(path) {
...

function ast-types.PathVisitor.prototype.acquireContext (path)

description and source-code

acquireContext = function (path) {
    if (this._reusableContextStack.length === 0) {
        return new this.Context(path);
    }
    return this._reusableContextStack.pop().reset(path);
}

example usage

...

var methodName = value &&
  typeof value === "object" &&
  typeof value.type === "string" &&
  this._methodNameTable[value.type];

if (methodName) {
    var context = this.acquireContext(path);
    try {
        return context.invokeVisitorMethod(methodName);
    } finally {
        this.releaseContext(context);
    }

} else {
...

function ast-types.PathVisitor.prototype.releaseContext (context)

description and source-code

releaseContext = function (context) {
    if (!(context instanceof this.Context)) {
        throw new Error("");
    }
    this._reusableContextStack.push(context);
    context.currentPath = null;
}

example usage

...
  this._methodNameTable[value.type];

if (methodName) {
    var context = this.acquireContext(path);
    try {
        return context.invokeVisitorMethod(methodName);
    } finally {
        this.releaseContext(context);
    }

} else {
    // If there was no visitor method to call, visit the children of
    // this node generically.
    return visitChildren(path, this);
}
...

function ast-types.PathVisitor.prototype.reportChanged ()

description and source-code

reportChanged = function () {
    this._changeReported = true;
}

example usage

...

      return PathVisitor.fromMethodsObject(
        newVisitor || this.visitor
      ).visitWithoutReset(path);
  };

sharedContextProtoMethods.reportChanged = function reportChanged() {
    this.visitor.reportChanged();
};

sharedContextProtoMethods.abort = function abort() {
    this.needToCallTraverse = false;
    this.visitor.abort();
};
...

function ast-types.PathVisitor.prototype.reset (path)

description and source-code

reset = function (path) {
    // Empty stub; may be reassigned or overridden by subclasses.
}

example usage

...
    return path.value;
}

PVp.acquireContext = function (path) {
    if (this._reusableContextStack.length === 0) {
        return new this.Context(path);
    }
    return this._reusableContextStack.pop().reset(path);
};

PVp.releaseContext = function (context) {
    if (!(context instanceof this.Context)) {
        throw new Error("");
    }
    this._reusableContextStack.push(context);
...

function ast-types.PathVisitor.prototype.visit ()

description and source-code

visit = function () {
    if (this._visiting) {
        throw new Error(
          "Recursively calling visitor.visit(path) resets visitor state. " +
          "Try this.visit(path) or this.traverse(path) instead."
        );
    }

    // Private state that needs to be reset before every traversal.
    this._visiting = true;
    this._changeReported = false;
    this._abortRequested = false;

    var argc = arguments.length;
    var args = new Array(argc)
    for (var i = 0; i < argc; ++i) {
        args[i] = arguments[i];
    }

    if (!(args[0] instanceof NodePath)) {
        args[0] = new NodePath({root: args[0]}).get("root");
    }

    // Called with the same arguments as .visit.
    this.reset.apply(this, args);

    try {
        var root = this.visitWithoutReset(args[0]);
        var didNotThrow = true;
    } finally {
        this._visiting = false;

        if (!didNotThrow && this._abortRequested) {
            // If this.visitWithoutReset threw an exception and
            // this._abortRequested was set to true, return the root of
            // the AST instead of letting the exception propagate, so that
            // client code does not have to provide a try-catch block to
            // intercept the AbortRequest exception.  Other kinds of
            // exceptions will propagate without being intercepted and
            // rethrown by a catch block, so their stacks will accurately
            // reflect the original throwing context.
            return args[0].value;
        }
    }

    return root;
}

example usage

...
Here's a trivial example of how you might assert that `arguments.callee`
is never used in `ast`:
```js
var assert = require("assert");
var types = require("ast-types");
var n = types.namedTypes;

types.visit(ast, {
    // This method will be called for any node with .type "MemberExpression":
    visitMemberExpression: function(path) {
// Visitor methods receive a single argument, a NodePath object
// wrapping the node of interest.
var node = path.node;

if (n.Identifier.check(node.object) &&
...

function ast-types.PathVisitor.prototype.visitWithoutReset (path)

description and source-code

visitWithoutReset = function (path) {
    if (this instanceof this.Context) {
        // Since this.Context.prototype === this, there's a chance we
        // might accidentally call context.visitWithoutReset. If that
        // happens, re-invoke the method against context.visitor.
        return this.visitor.visitWithoutReset(path);
    }

    if (!(path instanceof NodePath)) {
        throw new Error("");
    }

    var value = path.value;

    var methodName = value &&
      typeof value === "object" &&
      typeof value.type === "string" &&
      this._methodNameTable[value.type];

    if (methodName) {
        var context = this.acquireContext(path);
        try {
            return context.invokeVisitorMethod(methodName);
        } finally {
            this.releaseContext(context);
        }

    } else {
        // If there was no visitor method to call, visit the children of
        // this node generically.
        return visitChildren(path, this);
    }
}

example usage

...
args[0] = new NodePath({root: args[0]}).get("root");
        }

        // Called with the same arguments as .visit.
        this.reset.apply(this, args);

        try {
var root = this.visitWithoutReset(args[0]);
var didNotThrow = true;
        } finally {
this._visiting = false;

if (!didNotThrow && this._abortRequested) {
    // If this.visitWithoutReset threw an exception and
    // this._abortRequested was set to true, return the root of
...

function ast-types.PathVisitor.prototype.wasChangeReported ()

description and source-code

wasChangeReported = function () {
    return this._changeReported;
}

example usage
```
n/a
```

module ast-types.Type

function ast-types.Type (check, name)

description and source-code

function Type(check, name) {
    var self = this;
    if (!(self instanceof Type)) {
        throw new Error("Type constructor cannot be invoked without 'new'");
    }

    // Unfortunately we can't elegantly reuse isFunction and isString,
    // here, because this code is executed while defining those types.
    if (objToStr.call(check) !== funObjStr) {
        throw new Error(check + " is not a function");
    }

    // The `name` parameter can be either a function or a string.
    var nameObjStr = objToStr.call(name);
    if (!(nameObjStr === funObjStr ||
      nameObjStr === strObjStr)) {
        throw new Error(name + " is neither a function nor a string");
    }

    Object.defineProperties(self, {
        name: {value: name},
        check: {
            value: function (value, deep) {
                var result = check.call(self, value, deep);
                if (!result && deep && objToStr.call(deep) === funObjStr)
                    deep(self, value);
                return result;
            }
        }
    });
}

example usage
```
n/a
```

function ast-types.Type.def (typeName)

description and source-code

def = function (typeName) {
    isString.assert(typeName);
    return hasOwn.call(defCache, typeName)
      ? defCache[typeName]
      : defCache[typeName] = new Def(typeName);
}

example usage
```
n/a
```

function ast-types.Type.fromArray (arr)

description and source-code

fromArray = function (arr) {
    if (!isArray.check(arr)) {
        throw new Error("");
    }
    if (arr.length !== 1) {
        throw new Error("only one element type is permitted for typed arrays");
    }
    return toType(arr[0]).arrayOf();
}

example usage

...
// The Def type is used as a helper for constructing compound
// interface types for AST nodes.
if (from instanceof Def)
    return from.type;

// Support [ElemType] syntax.
if (isArray.check(from))
    return Type.fromArray(from);

// Support { someField: FieldType, ... } syntax.
if (isObject.check(from))
    return Type.fromObject(from);

if (isFunction.check(from)) {
    var bicfIndex = builtInCtorFns.indexOf(from);
...

function ast-types.Type.fromObject (obj)

description and source-code

fromObject = function (obj) {
    var fields = Object.keys(obj).map(function (name) {
        return new Field(name, obj[name]);
    });

    return new Type(function (value, deep) {
        return isObject.check(value) && fields.every(function (field) {
              return field.type.check(value[field.name], deep);
          });
    }, function () {
        return "{ " + fields.join(", ") + " }";
    });
}

example usage

...

// Support [ElemType] syntax.
if (isArray.check(from))
    return Type.fromArray(from);

// Support { someField: FieldType, ... } syntax.
if (isObject.check(from))
    return Type.fromObject(from);

if (isFunction.check(from)) {
    var bicfIndex = builtInCtorFns.indexOf(from);
    if (bicfIndex >= 0) {
        return builtInCtorTypes[bicfIndex];
    }
...

function ast-types.Type.or ()

description and source-code

or = function () {
    var types = [];
    var len = arguments.length;
    for (var i = 0; i < len; ++i)
        types.push(toType(arguments[i]));

    return new Type(function (value, deep) {
        for (var i = 0; i < len; ++i)
            if (types[i].check(value, deep))
                return true;
        return false;
    }, function () {
        return types.join(" | ");
    });
}

example usage

...
    "null": function () { return null },
    "emptyArray": function () { return [] },
    "false": function () { return false },
    "true": function () { return true },
    "undefined": function () {}
};

var naiveIsPrimitive = Type.or(
  builtin.string,
  builtin.number,
  builtin.boolean,
  builtin.null,
  builtin.undefined
);
...

module ast-types.Type.prototype

function ast-types.Type.prototype.arrayOf ()

description and source-code

arrayOf = function () {
    var elemType = this;
    return new Type(function (value, deep) {
        return isArray.check(value) && value.every(function (elem) {
              return elemType.check(elem, deep);
          });
    }, function () {
        return "[" + elemType + "]";
    });
}

example usage

...
Type.fromArray = function (arr) {
    if (!isArray.check(arr)) {
        throw new Error("");
    }
    if (arr.length !== 1) {
        throw new Error("only one element type is permitted for typed arrays");
    }
    return toType(arr[0]).arrayOf();
};

Tp.arrayOf = function () {
    var elemType = this;
    return new Type(function (value, deep) {
        return isArray.check(value) && value.every(function (elem) {
              return elemType.check(elem, deep);
...

function ast-types.Type.prototype.assert (value, deep)

description and source-code

assert = function (value, deep) {
    if (!this.check(value, deep)) {
        var str = shallowStringify(value);
        throw new Error(str + " does not match type " + this);
    }
    return true;
}

example usage

...
// rest parameters.
if (!node.rest) {
    return;
}

// For the purposes of this example, we won't worry about functions
// with Expression bodies.
n.BlockStatement.assert(node.body);

// Use types.builders to build a variable declaration of the form
//
//   var rest = Array.prototype.slice.call(arguments, n);
//
// where `rest` is the name of the rest parameter, and `n` is a
// numeric literal specifying the number of named parameters the
...

function ast-types.Type.prototype.toString ()

description and source-code

toString = function () {
    var name = this.name;

    if (isString.check(name))
        return name;

    if (isFunction.check(name))
        return name.call(this) + "";

    return name + " type";
}

example usage

...
    }
} else {
    prefix = "t$";
}

// Include this.depth in the name to make sure the name does not
// collide with any variables in nested/enclosing scopes.
prefix += this.depth.toString(36) + "$";

this.scan();

var index = 0;
while (this.declares(prefix + index)) {
    ++index;
}
...

module ast-types.astNodesAreEquivalent

function ast-types.astNodesAreEquivalent (a, b, problemPath)

description and source-code

function astNodesAreEquivalent(a, b, problemPath) {
    if (isArray.check(problemPath)) {
        problemPath.length = 0;
    } else {
        problemPath = null;
    }

    return areEquivalent(a, b, problemPath);
}

example usage
```
n/a
```

function ast-types.astNodesAreEquivalent.assert (a, b)

description and source-code

assert = function (a, b) {
    var problemPath = [];
    if (!astNodesAreEquivalent(a, b, problemPath)) {
        if (problemPath.length === 0) {
            if (a !== b) {
                throw new Error("Nodes must be equal");
            }
        } else {
            throw new Error(
              "Nodes differ in the following path: " +
              problemPath.map(subscriptForProperty).join("")
            );
        }
    }
}

example usage

...
// rest parameters.
if (!node.rest) {
    return;
}

// For the purposes of this example, we won't worry about functions
// with Expression bodies.
n.BlockStatement.assert(node.body);

// Use types.builders to build a variable declaration of the form
//
//   var rest = Array.prototype.slice.call(arguments, n);
//
// where `rest` is the name of the rest parameter, and `n` is a
// numeric literal specifying the number of named parameters the
...

module ast-types.builders

function ast-types.builders.anyTypeAnnotation ()

description and source-code

anyTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.arrayExpression ()

description and source-code

arrayExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.arrayPattern ()

description and source-code

arrayPattern = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.arrayStatement ()

description and source-code

arrayStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.arrayTypeAnnotation ()

description and source-code

arrayTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.arrowFunctionExpression ()

description and source-code

arrowFunctionExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.arrowFunctionStatement ()

description and source-code

arrowFunctionStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.assignmentExpression ()

description and source-code

assignmentExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.assignmentPattern ()

description and source-code

assignmentPattern = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.assignmentStatement ()

description and source-code

assignmentStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.awaitExpression ()

description and source-code

awaitExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.awaitStatement ()

description and source-code

awaitStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.binaryExpression ()

description and source-code

binaryExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage

...
// arguments, as named by .build("name", "program") above.
var main = b.file("main.js", b.program([
    // Pointless program contents included for extra color.
    b.functionDeclaration(b.identifier("succ"), [
        b.identifier("x")
    ], b.blockStatement([
        b.returnStatement(
            b.binaryExpression(
                "+", b.identifier("x"), b.literal(1)
            )
        )
    ]))
]));

assert.strictEqual(main.name, "main.js");
...

function ast-types.builders.binaryStatement ()

description and source-code

binaryStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.bindExpression ()

description and source-code

bindExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.bindStatement ()

description and source-code

bindStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.block ()

description and source-code

block = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.blockStatement ()

description and source-code

blockStatement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage

...
---
```js
var assert = require("assert");
var n = require("ast-types").namedTypes;
var b = require("ast-types").builders;

var fooId = b.identifier("foo");
var ifFoo = b.ifStatement(fooId, b.blockStatement([
    b.expressionStatement(b.callExpression(fooId, []))
]));

assert.ok(n.IfStatement.check(ifFoo));
assert.ok(n.Statement.check(ifFoo));
assert.ok(n.Node.check(ifFoo));
...

function ast-types.builders.booleanLiteral ()

description and source-code

booleanLiteral = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.booleanLiteralStatement ()

description and source-code

booleanLiteralStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.booleanLiteralTypeAnnotation ()

description and source-code

booleanLiteralTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.booleanTypeAnnotation ()

description and source-code

booleanTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.breakStatement ()

description and source-code

breakStatement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.callExpression ()

description and source-code

callExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage

...
```js
var assert = require("assert");
var n = require("ast-types").namedTypes;
var b = require("ast-types").builders;

var fooId = b.identifier("foo");
var ifFoo = b.ifStatement(fooId, b.blockStatement([
    b.expressionStatement(b.callExpression(fooId, []))
]));

assert.ok(n.IfStatement.check(ifFoo));
assert.ok(n.Statement.check(ifFoo));
assert.ok(n.Node.check(ifFoo));

assert.ok(n.BlockStatement.check(ifFoo.consequent));
...

function ast-types.builders.callStatement ()

description and source-code

callStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.catchClause ()

description and source-code

catchClause = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.classBody ()

description and source-code

classBody = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.classDeclaration ()

description and source-code

classDeclaration = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.classExpression ()

description and source-code

classExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.classImplements ()

description and source-code

classImplements = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.classMethod ()

description and source-code

classMethod = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.classProperty ()

description and source-code

classProperty = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.classPropertyDefinition ()

description and source-code

classPropertyDefinition = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.classStatement ()

description and source-code

classStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.commentBlock ()

description and source-code

commentBlock = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.commentLine ()

description and source-code

commentLine = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.comprehensionBlock ()

description and source-code

comprehensionBlock = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.comprehensionExpression ()

description and source-code

comprehensionExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.comprehensionStatement ()

description and source-code

comprehensionStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.conditionalExpression ()

description and source-code

conditionalExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.conditionalStatement ()

description and source-code

conditionalStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.continueStatement ()

description and source-code

continueStatement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.debuggerStatement ()

description and source-code

debuggerStatement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.declareClass ()

description and source-code

declareClass = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.declareExportAllDeclaration ()

description and source-code

declareExportAllDeclaration = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.declareExportDeclaration ()

description and source-code

declareExportDeclaration = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.declareFunction ()

description and source-code

declareFunction = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.declareInterface ()

description and source-code

declareInterface = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.declareModule ()

description and source-code

declareModule = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.declareModuleExports ()

description and source-code

declareModuleExports = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.declareTypeAlias ()

description and source-code

declareTypeAlias = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.declareVariable ()

description and source-code

declareVariable = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.decorator ()

description and source-code

decorator = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.directive ()

description and source-code

directive = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.directiveLiteral ()

description and source-code

directiveLiteral = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.directiveLiteralStatement ()

description and source-code

directiveLiteralStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.doExpression ()

description and source-code

doExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.doStatement ()

description and source-code

doStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.doWhileStatement ()

description and source-code

doWhileStatement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.emptyStatement ()

description and source-code

emptyStatement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.emptyTypeAnnotation ()

description and source-code

emptyTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.existentialTypeParam ()

description and source-code

existentialTypeParam = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.existsTypeAnnotation ()

description and source-code

existsTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.exportAllDeclaration ()

description and source-code

exportAllDeclaration = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.exportBatchSpecifier ()

description and source-code

exportBatchSpecifier = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.exportDeclaration ()

description and source-code

exportDeclaration = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.exportDefaultDeclaration ()

description and source-code

exportDefaultDeclaration = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.exportDefaultSpecifier ()

description and source-code

exportDefaultSpecifier = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.exportNamedDeclaration ()

description and source-code

exportNamedDeclaration = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.exportNamespaceSpecifier ()

description and source-code

exportNamespaceSpecifier = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.exportSpecifier ()

description and source-code

exportSpecifier = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.expressionStatement ()

description and source-code

expressionStatement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage

...
```js
var assert = require("assert");
var n = require("ast-types").namedTypes;
var b = require("ast-types").builders;

var fooId = b.identifier("foo");
var ifFoo = b.ifStatement(fooId, b.blockStatement([
    b.expressionStatement(b.callExpression(fooId, []))
]));

assert.ok(n.IfStatement.check(ifFoo));
assert.ok(n.Statement.check(ifFoo));
assert.ok(n.Node.check(ifFoo));

assert.ok(n.BlockStatement.check(ifFoo.consequent));
...

function ast-types.builders.file ()

description and source-code

file = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage

...

// Prevent further modifications to the File type (and any other
// types newly introduced by def(...)).
types.finalize();

// The b.file builder function is now available. It expects two
// arguments, as named by .build("name", "program") above.
var main = b.file("main.js", b.program([
// Pointless program contents included for extra color.
b.functionDeclaration(b.identifier("succ"), [
    b.identifier("x")
], b.blockStatement([
    b.returnStatement(
        b.binaryExpression(
            "+", b.identifier("x"), b.literal(1)
...

function ast-types.builders.forAwaitStatement ()

description and source-code

forAwaitStatement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.forInStatement ()

description and source-code

forInStatement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.forOfStatement ()

description and source-code

forOfStatement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.forStatement ()

description and source-code

forStatement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.functionDeclaration ()

description and source-code

functionDeclaration = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage

...
// types newly introduced by def(...)).
types.finalize();

// The b.file builder function is now available. It expects two
// arguments, as named by .build("name", "program") above.
var main = b.file("main.js", b.program([
// Pointless program contents included for extra color.
b.functionDeclaration(b.identifier("succ"), [
    b.identifier("x")
], b.blockStatement([
    b.returnStatement(
        b.binaryExpression(
            "+", b.identifier("x"), b.literal(1)
        )
    )
...

function ast-types.builders.functionExpression ()

description and source-code

functionExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.functionStatement ()

description and source-code

functionStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.functionTypeAnnotation ()

description and source-code

functionTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.functionTypeParam ()

description and source-code

functionTypeParam = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.generatorExpression ()

description and source-code

generatorExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.generatorStatement ()

description and source-code

generatorStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.genericTypeAnnotation ()

description and source-code

genericTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.graphExpression ()

description and source-code

graphExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.graphIndexExpression ()

description and source-code

graphIndexExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.graphIndexStatement ()

description and source-code

graphIndexStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.graphStatement ()

description and source-code

graphStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.identifier ()

description and source-code

identifier = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage

...
Basic Usage
---
```js
var assert = require("assert");
var n = require("ast-types").namedTypes;
var b = require("ast-types").builders;

var fooId = b.identifier("foo");
var ifFoo = b.ifStatement(fooId, b.blockStatement([
    b.expressionStatement(b.callExpression(fooId, []))
]));

assert.ok(n.IfStatement.check(ifFoo));
assert.ok(n.Statement.check(ifFoo));
assert.ok(n.Node.check(ifFoo));
...

function ast-types.builders.identifierStatement ()

description and source-code

identifierStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.ifStatement ()

description and source-code

ifStatement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage

...
---
```js
var assert = require("assert");
var n = require("ast-types").namedTypes;
var b = require("ast-types").builders;

var fooId = b.identifier("foo");
var ifFoo = b.ifStatement(fooId, b.blockStatement([
    b.expressionStatement(b.callExpression(fooId, []))
]));

assert.ok(n.IfStatement.check(ifFoo));
assert.ok(n.Statement.check(ifFoo));
assert.ok(n.Node.check(ifFoo));
...

function ast-types.builders.import ()

description and source-code

import = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.importDeclaration ()

description and source-code

importDeclaration = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.importDefaultSpecifier ()

description and source-code

importDefaultSpecifier = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.importNamespaceSpecifier ()

description and source-code

importNamespaceSpecifier = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.importSpecifier ()

description and source-code

importSpecifier = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.importStatement ()

description and source-code

importStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.interfaceDeclaration ()

description and source-code

interfaceDeclaration = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.interfaceExtends ()

description and source-code

interfaceExtends = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.intersectionTypeAnnotation ()

description and source-code

intersectionTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.jsxAttribute ()

description and source-code

jsxAttribute = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.jsxClosingElement ()

description and source-code

jsxClosingElement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.jsxElement ()

description and source-code

jsxElement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.jsxElementStatement ()

description and source-code

jsxElementStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.jsxEmptyExpression ()

description and source-code

jsxEmptyExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.jsxEmptyStatement ()

description and source-code

jsxEmptyStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.jsxExpressionContainer ()

description and source-code

jsxExpressionContainer = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.jsxExpressionContainerStatement ()

description and source-code

jsxExpressionContainerStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.jsxIdentifier ()

description and source-code

jsxIdentifier = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.jsxIdentifierStatement ()

description and source-code

jsxIdentifierStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.jsxMemberExpression ()

description and source-code

jsxMemberExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.jsxMemberStatement ()

description and source-code

jsxMemberStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.jsxNamespacedName ()

description and source-code

jsxNamespacedName = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.jsxOpeningElement ()

description and source-code

jsxOpeningElement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.jsxSpreadAttribute ()

description and source-code

jsxSpreadAttribute = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.jsxSpreadChild ()

description and source-code

jsxSpreadChild = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.jsxSpreadChildStatement ()

description and source-code

jsxSpreadChildStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.jsxText ()

description and source-code

jsxText = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.jsxTextStatement ()

description and source-code

jsxTextStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.labeledStatement ()

description and source-code

labeledStatement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.letExpression ()

description and source-code

letExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.letStatement ()

description and source-code

letStatement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.line ()

description and source-code

line = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.literal ()

description and source-code

literal = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage

...
// numeric literal specifying the number of named parameters the
// function takes.
var restVarDecl = b.variableDeclaration("var", [
    b.variableDeclarator(
        node.rest,
        b.callExpression(sliceExpr, [
            b.identifier("arguments"),
            b.literal(node.params.length)
        ])
    )
]);

// Similar to doing node.body.body.unshift(restVarDecl), except
// that the other NodePath objects wrapping body statements will
// have their indexes updated to accommodate the new statement.
...

function ast-types.builders.literalStatement ()

description and source-code

literalStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.logicalExpression ()

description and source-code

logicalExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.logicalStatement ()

description and source-code

logicalStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.memberExpression ()

description and source-code

memberExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage

...
Here's a slightly more involved example of transforming `...rest`
parameters into browser-runnable ES5 JavaScript:

```js
var b = types.builders;

// Reuse the same AST structure for Array.prototype.slice.call.
var sliceExpr = b.memberExpression(
b.memberExpression(
    b.memberExpression(
        b.identifier("Array"),
        b.identifier("prototype"),
        false
    ),
    b.identifier("slice"),
...

function ast-types.builders.memberStatement ()

description and source-code

memberStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.memberTypeAnnotation ()

description and source-code

memberTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.metaProperty ()

description and source-code

metaProperty = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.metaPropertyStatement ()

description and source-code

metaPropertyStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.methodDefinition ()

description and source-code

methodDefinition = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.mixedTypeAnnotation ()

description and source-code

mixedTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.newExpression ()

description and source-code

newExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.newStatement ()

description and source-code

newStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.noop ()

description and source-code

noop = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.nullLiteral ()

description and source-code

nullLiteral = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.nullLiteralStatement ()

description and source-code

nullLiteralStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.nullLiteralTypeAnnotation ()

description and source-code

nullLiteralTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.nullTypeAnnotation ()

description and source-code

nullTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.nullableTypeAnnotation ()

description and source-code

nullableTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.numberLiteralTypeAnnotation ()

description and source-code

numberLiteralTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.numberTypeAnnotation ()

description and source-code

numberTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.numericLiteral ()

description and source-code

numericLiteral = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.numericLiteralStatement ()

description and source-code

numericLiteralStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.numericLiteralTypeAnnotation ()

description and source-code

numericLiteralTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.objectExpression ()

description and source-code

objectExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.objectMethod ()

description and source-code

objectMethod = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.objectPattern ()

description and source-code

objectPattern = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.objectProperty ()

description and source-code

objectProperty = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.objectStatement ()

description and source-code

objectStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.objectTypeAnnotation ()

description and source-code

objectTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.objectTypeCallProperty ()

description and source-code

objectTypeCallProperty = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.objectTypeIndexer ()

description and source-code

objectTypeIndexer = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.objectTypeProperty ()

description and source-code

objectTypeProperty = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.parenthesizedExpression ()

description and source-code

parenthesizedExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.parenthesizedStatement ()

description and source-code

parenthesizedStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.position ()

description and source-code

position = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.program ()

description and source-code

program = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage

...

// Prevent further modifications to the File type (and any other
// types newly introduced by def(...)).
types.finalize();

// The b.file builder function is now available. It expects two
// arguments, as named by .build("name", "program") above.
var main = b.file("main.js", b.program([
// Pointless program contents included for extra color.
b.functionDeclaration(b.identifier("succ"), [
    b.identifier("x")
], b.blockStatement([
    b.returnStatement(
        b.binaryExpression(
            "+", b.identifier("x"), b.literal(1)
...

function ast-types.builders.property ()

description and source-code

property = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.propertyPattern ()

description and source-code

propertyPattern = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.qualifiedTypeIdentifier ()

description and source-code

qualifiedTypeIdentifier = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.regExpLiteral ()

description and source-code

regExpLiteral = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.regExpLiteralStatement ()

description and source-code

regExpLiteralStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.restElement ()

description and source-code

restElement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.restProperty ()

description and source-code

restProperty = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.returnStatement ()

description and source-code

returnStatement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage

...
// The b.file builder function is now available. It expects two
// arguments, as named by .build("name", "program") above.
var main = b.file("main.js", b.program([
    // Pointless program contents included for extra color.
    b.functionDeclaration(b.identifier("succ"), [
        b.identifier("x")
    ], b.blockStatement([
        b.returnStatement(
            b.binaryExpression(
                "+", b.identifier("x"), b.literal(1)
            )
        )
    ]))
]));
...

function ast-types.builders.sequenceExpression ()

description and source-code

sequenceExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.sequenceStatement ()

description and source-code

sequenceStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.sourceLocation ()

description and source-code

sourceLocation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.spreadElement ()

description and source-code

spreadElement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.spreadElementPattern ()

description and source-code

spreadElementPattern = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.spreadProperty ()

description and source-code

spreadProperty = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.spreadPropertyPattern ()

description and source-code

spreadPropertyPattern = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.stringLiteral ()

description and source-code

stringLiteral = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.stringLiteralStatement ()

description and source-code

stringLiteralStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.stringLiteralTypeAnnotation ()

description and source-code

stringLiteralTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.stringTypeAnnotation ()

description and source-code

stringTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.super ()

description and source-code

super = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.superStatement ()

description and source-code

superStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.switchCase ()

description and source-code

switchCase = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.switchStatement ()

description and source-code

switchStatement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.taggedTemplateExpression ()

description and source-code

taggedTemplateExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.taggedTemplateStatement ()

description and source-code

taggedTemplateStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.templateElement ()

description and source-code

templateElement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.templateLiteral ()

description and source-code

templateLiteral = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.templateLiteralStatement ()

description and source-code

templateLiteralStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.thisExpression ()

description and source-code

thisExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage

...
// Now do some stuff that might rearrange the list, and this replacement
// remains safe:
fifth.replace(newerNode);

// Replace the third element in an array with two new nodes:
path.get("elements", 2).replace(
    b.identifier("foo"),
    b.thisExpression()
);

// Remove a node and its parent if it would leave a redundant AST node:
//e.g. var t = 1, y =2; removing the `t` and `y` declarators results in `var undefined`.
path.prune(); //returns the closest parent `NodePath`.

// Remove a node from a list of nodes:
...

function ast-types.builders.thisStatement ()

description and source-code

thisStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.thisTypeAnnotation ()

description and source-code

thisTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.throwStatement ()

description and source-code

throwStatement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.tryStatement ()

description and source-code

tryStatement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.tupleTypeAnnotation ()

description and source-code

tupleTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.typeAlias ()

description and source-code

typeAlias = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.typeAnnotation ()

description and source-code

typeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.typeCastExpression ()

description and source-code

typeCastExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.typeCastStatement ()

description and source-code

typeCastStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.typeParameter ()

description and source-code

typeParameter = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.typeParameterDeclaration ()

description and source-code

typeParameterDeclaration = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.typeParameterInstantiation ()

description and source-code

typeParameterInstantiation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.typeofTypeAnnotation ()

description and source-code

typeofTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.unaryExpression ()

description and source-code

unaryExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage

...
        var consequent = ifStatement.get('consequent').value;

        if (!consequent && !alternate) {
var testExpressionStatement = b.expressionStatement(testExpression);

ifStatement.replace(testExpressionStatement);
        } else if (!consequent && alternate) {
var negatedTestExpression = b.unaryExpression('!', testExpression, true);

if (n.UnaryExpression.check(testExpression) && testExpression.operator === '!') {
    negatedTestExpression = testExpression.argument;
}

ifStatement.get("test").replace(negatedTestExpression);
ifStatement.get("consequent").replace(alternate);
...

function ast-types.builders.unaryStatement ()

description and source-code

unaryStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.unionTypeAnnotation ()

description and source-code

unionTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.updateExpression ()

description and source-code

updateExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.updateStatement ()

description and source-code

updateStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

function ast-types.builders.variableDeclaration ()

description and source-code

variableDeclaration = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage

...
// Use types.builders to build a variable declaration of the form
//
//   var rest = Array.prototype.slice.call(arguments, n);
//
// where `rest` is the name of the rest parameter, and `n` is a
// numeric literal specifying the number of named parameters the
// function takes.
var restVarDecl = b.variableDeclaration("var", [
    b.variableDeclarator(
        node.rest,
        b.callExpression(sliceExpr, [
            b.identifier("arguments"),
            b.literal(node.params.length)
        ])
    )
...

function ast-types.builders.variableDeclarator ()

description and source-code

variableDeclarator = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage

...
//
//   var rest = Array.prototype.slice.call(arguments, n);
//
// where `rest` is the name of the rest parameter, and `n` is a
// numeric literal specifying the number of named parameters the
// function takes.
var restVarDecl = b.variableDeclaration("var", [
    b.variableDeclarator(
        node.rest,
        b.callExpression(sliceExpr, [
            b.identifier("arguments"),
            b.literal(node.params.length)
        ])
    )
]);
...

function ast-types.builders.voidTypeAnnotation ()

description and source-code

voidTypeAnnotation = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.whileStatement ()

description and source-code

whileStatement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.withStatement ()

description and source-code

withStatement = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.yieldExpression ()

description and source-code

yieldExpression = function () {
    var args = arguments;
    var argc = args.length;
    var built = Object.create(nodePrototype);

    if (!self.finalized) {
        throw new Error(
          "attempting to instantiate unfinalized type " +
          self.typeName
        );
    }

    function add(param, i) {
        if (hasOwn.call(built, param))
            return;

        var all = self.allFields;
        if (!hasOwn.call(all, param)) {
            throw new Error("" + param);
        }

        var field = all[param];
        var type = field.type;
        var value;

        if (isNumber.check(i) && i < argc) {
            value = args[i];
        } else if (field.defaultFn) {
            // Expose the partially-built object to the default
            // function as its `this` object.
            value = field.defaultFn.call(built);
        } else {
            var message = "no value or default function given for field " +
              JSON.stringify(param) + " of " + self.typeName + "(" +
              self.buildParams.map(function (name) {
                  return all[name];
              }).join(", ") + ")";
            throw new Error(message);
        }

        if (!type.check(value)) {
            throw new Error(
              shallowStringify(value) +
              " does not match field " + field +
              " of type " + self.typeName
            );
        }

        // TODO Could attach getters and setters here to enforce
        // dynamic type safety.
        built[param] = value;
    }

    self.buildParams.forEach(function (param, i) {
        add(param, i);
    });

    Object.keys(self.allFields).forEach(function (param) {
        add(param); // Use the default value.
    });

    // Make sure that the "type" field was filled automatically.
    if (built.type !== self.typeName) {
        throw new Error("");
    }

    return built;
}

example usage
```
n/a
```

function ast-types.builders.yieldStatement ()

description and source-code

yieldStatement = function () {
    return builders.expressionStatement(wrapped.apply(builders, arguments));
}

example usage
```
n/a
```

api documentation for ast-types (v0.9.11)

Esprima-compatible implementation of the Mozilla JS Parser API

table of contents