getFieldType? about ast-types HOT 3 OPEN

I suppose even this wouldn't be sufficient since MemberExpression's property could be an identifier, but the identifier behaves like an expression only if computed is true. It seems like every node simply needs to be special cased which is a bit strange.

from ast-types.

In the specific case of Identifier nodes, the ast-util project has a utility function for determining if the identifier is a reference: https://github.com/eventualbuddha/ast-util#user-content-isReference. And yeah, it is pretty tricky.

from ast-types.

In general, if you're writing a visitor, you can use the NodePath to inspect the parent node(s):

var MemberExpression = types.namedTypes.MemberExpression;
types.visit(ast, {
  visitIdentifier: function(path) {
    this.traverse(path);

    var node = path.node;
    var parentNode = path.parent.node;

    if (MemberExpression.check(parentNode) &&
        path.name === "property" &&
        !parentNode.computed) {
      // Do something with identifiers that are not member expression .properties.
    }
  }
});

Since nodes can appear multiple times in the same AST, there's no safe way for AST nodes themselves to have a .parent property. Instead, you have to keep track of the ancestor path as you traverse, which is what NodePath is for :)

Specifically, path is a NodePath object, path.node is the current node, path.parent is a NodePath for the parent node, path.parent.node is the parent node, path.parent.parent.node is the grandparent node, and so on.

The path.name property is useful for pathological (punny?) cases where you can't tell children apart using ===:

var b = types.builders;
var id = b.identifier("foo");

// The expression foo.foo:
var mx = b.memberExpression(id, id, false);

assert.strictEqual(mx.object, mx.property);

var path = new NodePath(mx);
var objPath = path.get("object");
var propPath = path.get("property");

assert.strictEqual(objPath.node, id);
assert.strictEqual(propPath.node, id);

assert.strictEqual(objPath.name, "object");
assert.strictEqual(propPath.name, "property");

from ast-types.