Support for assignments and for binary operation expressions

[malteskoruppa]

Support for assignments

• AST_ASSIGN -> ast.expressions.AssignmentExpression
• AST_ASSIGN_REF -> ast.php.expressions.PHPAssignmentByRefExpression
• AST_ASSIGN_OP -> ast.expressions.AssignmentWithOpExpression

A few comments on this:

1. I renamed the already existing class AssignmentExpr into AssignmentExpression and fixed C world accordingly. The reason is consistency: All other node classes whose name matches ^.*Expr.*$ have a name that matches ^.*Expression$, except for AssignmentExpr and SizeofExpr. (In the same spirit I would suggest renaming SizeofExpr too, but since there is no sizeof operator in PHP, I did not touch this node. I will add a comment to issue Some refactorings to abstract from C and PHP #80, though.)
2. I refactored the class BinaryExpression (which is the parent of AssignmentExpression) to not override getChildCount() and getChild(int) any longer. I think that when maintaining an AST node's children cleanly, overriding either of these two methods inherited from ASTNode should never be necessary, as the super-methods in ASTNode should always do the right thing. Whenever such an override is present and necessary in a node class, it is a sign that something else was done uncleanly before. In this particular case however, removing these methods does not break anything, as the super-methods return the same values as the overriding methods did anyway. Thus I suppose these overrides were some kind of legacy restover from earlier versions of Joern, and are not needed any longer.
3. I also enriched the class AssignmentExpression with public methods getVariable() and getAssignExpression() (and corresponding setters) which only relay to the protected methods getLeft() and getRight() (accordingly for the setters) from the BinaryExpression parent class, for added comfort and consistency.
4. As opposed to C, PHP supports references only in a limited way (mostly, in assignments and as function parameters): For assignments, there is an explicit "assignment by reference" operator =& (often written as $a = &$b in the C spirit, but actually, the form $a =& $b is technically more accurate; both forms are acceptable in PHP and generate identical ASTs). Since this operator is quite php-specific, I introduced an ast.php.expressions.PHPAssignmentByRefExpression which extends ast.expressions.AssignmentExpression.
5. In the case of the "combined assignment and binary operation" operators (e.g., +=, *=, .=, etc.), I declared a new base class ast.expressions.AssignmentWithOpExpression, since such assignment operations exist in other high-level languages as well (say, Java).

Support for binary operation expressions

• AST_BINARY_OP -> ast.expressions.BinaryOperationExpression

I introduced a new class BinaryOperationExpression which extends BinaryExpression, and made this new class a common parent for the following nodes in the ast.expressions package (these nodes previously extended BinaryExpression directly):

• AdditiveExpression
• AndExpression
• BitAndExpression
• EqualityExpression
• ExclusiveOrExpression
• InclusiveOrExpression
• MultiplicativeExpression
• OrExpression
• RelationalExpression
• ShiftExpression

Thereby, the class BinaryExpression now only has two direct children: AssignmentExpression and BinaryOperationExpression. This gives us a more fine-grained understanding of the various kinds of nodes that exist by making a clear distinction between assignment expressions and binary operation expressions, both of which are binary expressions.

This change was also necessary because PHP ASTs do not use a distinguished kind of node for each kind of binary expression, as Joern does in C world; rather, (almost) all binary expressions are consistently represented as an AST_BINARY_OP node. The concrete operation that the node represents is specified via a flag on this node. Also see https://github.com/nikic/php-ast#flags.
Generally I think that's a good thing, because there are even more kinds of binary operation expressions in PHP than there are in C, and having a distinguished node for each of them would generate a lot of overhead. This "flag" approach is, by the way, also used for AST_ASSIGN_OP nodes (see bullet point 5 of the previous Support for assignments section.)

The following is a list of PHP's binary operators that will map to an AST_BINARY_OP node. This list makes every claim to completeness:

// bit operators
$or1 | $or2;
$and1 & $and2;
$msg ^ $otp;
$x << $y;
$x >> $y;
// string operators
$str1 . $str2;
// arithmetic operators
$x + $y;
$x - $y;
$x * $y;
$x / $y;
$x % $y;
$x ** $y;
// boolean operators
$x xor $y;
// comparison operators
$x === $y;
$x !== $y;
$x == $y;
$x != $y;
$x < $y;
$x <= $y;
$x <=> $y;

Support for "greater", "greater or equal", "and" and "or" expressions

• AST_AND -> ast.expressions.AndExpression
• AST_OR -> ast.expressions.OrExpression
• AST_GREATER -> ast.expressions.GreaterExpression
• AST_GREATER_EQUAL -> ast.expressions.GreaterOrEqualExpression

Here I added two new GreaterExpression and GreaterOrEqualExpression classes inheriting from the already existing RelationalExpression.

Thereby we also added support for the last remaining binary operators:

// boolean operators
$x && $y;
$x || $y;
// comparison operators
$x > $y;
$x >= $y;

Looking at this, you might wonder: "What? Why are there distinguished node kinds for these four binary operation expressions, when all other binary operation expressions are mapped to the same node kind with an appropriate flag? Why should greater and greater or equal have distinguished nodes, when less and less or equal don't? Or and and or when xor doesn't? That's completely inconsistent!"

You would be absolutely right. We are looking here at an inconsistent design of PHP ASTs. Remember that PHP ASTs are new, under development and their structure non-final. This inconsistency is quite probably due to some historic reason, but that's the way it is. However, this structure shall change in the future, and these four nodes will also be mapped to AST_BINARY_OP nodes with appropriate flags. In fact, Niki's php-ast extension already introduced this change in version 20 of the PHP ASTs: See https://github.com/nikic/php-ast#version-changelog (we are currently still using version 10). However, as version 20 is still marked as unstable and subject to change, I do not want to use it yet (I ought to upgrade to version 15 at some point, though, which will make next to no difference.) Hence, in the future, these four nodes will not be necessary any longer, as the corresponding expressions will be mapped to BinaryOperationExpression just as the other binary operation expressions are, too.

[fabsx00]

When we rename nodes, we will need to make sure none of the steps in python-joern still depend on the old name. I have created an issue for this: fabsx00/python-joern#13 to make sure that I don't forget about this before merging the phpsupport branch at some point.