As is, as far as I can tell, there's no way to easily compare two AST nodes to see if they have the same children and same fields (recursively).

I'm writing some unit tests for a NodeTransformers, so I've settled for comparing `ast.dump()`s of each, which is kind of dirty, but 1) works and 2) produces reasonable failure messages. (As a side note of what else I've tried, comparing, say, a list of the `iter_child_nodes` is not a good alternative, since the tests I'm writing are making assertions that a given node was not modified, which means they deepcopy the node and then want to assert that the "transformed" node is unchanged.)

I don't know the global implications of changing ast.AST.__eq__ to know if that's feasible (hopefully someone will comment on that), but if it isn't, another provided way would be nice.

This is a reasonable request. Should comparison include lineno/col_offset or not? If you implement, __eq__, you should also implement __hash__. Maybe, it would be best to start with a helper comparison function in the ast module.

I'd say yes (to both lineno/col_offset). And yeah that sounds like what I had in mind (a helper function).

If I'm specific for a moment about implementation, perhaps something like `ast.diff`, which yielded tuples of differing nodes (in say, breadth first order down the tree) from two given nodes, and took args for configuration, compare_lineno and compare_col_offset (both defaulted to True), and then __eq__ was just `next(ast.diff(self, other, compare_lineno=True, compare_col_offset=True), None) is None`.

Sound good to you?

Yes, though some things like what to return if one has an entire subtree that the other doesn't have will have to be worked out.

I have a use for this as well, but w/o the lineno/col_offset comparison and all I need is a True/False result.

IOW I think a function that uses ast.walk() and has flags for specifying whether _attributes should also be checked and then uses a class check and then uses _fields to do all other checking.

If we only need a binary True/False result, could we just return a compare of dump(a) == dump(b)?

This can also add the include_attributes flags for need.

Provide a recursive way to compare AST nodes, it will compare with fields, but no attributes.


The performance compare with ast.dump methods in unittest


# Recursive compare
./python -m unittest test.test_ast.ASTCompareTest
......
----------------------------------------------------------------------
Ran 6 tests in 0.669s

OK

# ast.dump compare
./python -m unittest test.test_ast.ASTCompareTest
......
----------------------------------------------------------------------
Ran 6 tests in 2.192s

Update to AST base type richcompare.

the unittest finished time was better than python version:

    Ran 7 tests in 0.278s

This discussion is inconclusive and targets an old version of CPython, can this issue be closed?

Closing issue, PR branch has since been removed and targets Python 3.4

Please don't close an issue too fast.

The PR 1368 is still open and contains valuable code.

Moreover, I don't see anyone here saying that the feature is a bad idea. The feature has not been implemented, so the issue should remain open, even if PR 1368 is outdated.

> ...issue... targets Python 3.4

Well, it's just that the issue has been created a long time ago, but the feature request remain value for Python 3.8.

Btw, I am +1 on this feature (preferably with an option to check line, column, end line, and end column). I always wanted this, but never had time to actually implement this.

If consensus has been reached on this, I am willing to do the work.

> If consensus has been reached on this, I am willing to do the work.

It looks like there is already an active PR https://github.com/python/cpython/pull/14970, there are some non-implemented comments from a core review.

I am not sure that implementing a rich comparison of AST nodes is the right way. There are too much options (compare attributes or not, compare recursively or not, compare types or not) and __eq__ does not support options. In addition, it requires implementing compatible __hash__, but how do you implement a hash of mutable object? In addition, recursive comparison can introduce a regression in existing code -- instead of fast returning False the comparison will spent a nontrivial amount of time.

If implement a comparison of AST nodes, it should be a separate function which support multiple options. Would be nice also to have examples where this feature can be used before implementing it.

See also issue37792.

The solution to hashing used in PR 14970 was just using the default hashing function which is kind of a workaround to the real problem. I now concur with your comments. Will try to draft out an `ast.compare` function.