How to support syntax like `a && b = c` for a conditional assignment expression?

Question

I want the expression a && b = c in my language to mean that the value of c is assigned to b when a is true, and nothing is done otherwise. In other words, the && operator short-circuits, and the expression b = c on the right-hand side is evaluated only when the left-hand side is true.

How can I define and implement this grammar rule in a programming language?

Answer 1

I am not an expert, so feel free to correct me if I've missed something fundamental here, but looking at the Bison parser for PHP, the way it is resolved there is not related to precedence, but to the productions defined.

Specifically, most binary operators (including &&) are defined as accepting any expression on the left-hand side; but assignment is defined as accepting a smaller set of syntax on the left-hand side.

In PHP's case, the token allowed on the left is called variable, but it might more generally be called an lvalue. The key limitations are:

• You need to distinguish in the grammar between "assignment operators" and other "binary operators". This may make a difference in a language with liberal operator overloading.
• You need to define in the grammar some subset of expressions which may be valid "lvalues". This can still include cases which fail at a later compiler phase, or even at run-time. It can even include '(' expression ')' so that (a && b) = c compiles, but means something different from a && b = c.

In the case of PHP:

• PHP does not allow operator overloading or custom operators, but does define combined assignment operators such as +=; these are handled with similar rules.
• It also has array destructuring ([$a, $b] = $array) which is handled as an additional rule for = only.
• The variable rule includes not just $foo but also other variable-like things, such as $object->property and SomeClass::$staticProperty.
• In fact, it also includes things which can't be assigned to, because of how it's reused in other parts of the parser: foo() = 42; gives a compilation error, but not a parser error.
• However, crucially, it doesn't include anything that matches $a && $b.

Here's an edited excerpt of PHP's Bison rules (without the target code which generates AST nodes):

expr:
        variable
    |   '[' array_pair_list ']' '=' expr
    |   variable '=' expr
    |   variable T_PLUS_EQUAL expr
    |   expr T_BOOLEAN_AND expr

variable:
        simple_variable
    |   static_member
    |   array_object_dereferenceable T_OBJECT_OPERATOR property_name
    |   array_object_dereferenceable T_NULLSAFE_OBJECT_OPERATOR property_name

Let's examine a simplified version with just assignment and logical and:

expression: variable | assignment | and_expression
assignment: variable '=' expression
and_expression: expression '&&' expression

Given the input $a && $b = $c, the stack will proceed as follows

• $a - shift - variable
• && - reduce, then shift - expression '&&'
• $b - shift - expression '&&' variable
• = - shift (because and_expression '=' does not match any rule) - expression '&&' variable '='
• $c - shift - expression '&&' variable '=' variable
• reduce - expression '&&' assignment
• reduce - expression '&&' expression
• reduce - and_expression
• reduce - expression

The resulting AST is equivalent to $a && ($b = $c)

Answer 2

PHP supports this:

<?php
$a = true; $a && $b = 1; echo $b;

Output:

1

Try it online!

Unfortunately, the documentation only says it is a special case in a note:

Note: Although = has a lower precedence than most other operators, PHP will still allow expressions similar to the following: if (!$a = foo()), in which case the return value of foo() is put into $a.

But this could be done by using different left and right operator precedence, just like how you usually implement brackets, where it has a high precedence outside but low precedence inside.

If you use a formal grammar, the number of symbols seems to explode:

level5 = identifier | constant | "(" level0 ")"
level4 = level5
level3 = level3 ("*" | "/") level4 | level4
level2 = level2 ("+" | "-") level3 | level3
level1 = level2 | level2_1
level4_1 = level4 "=" level1
level3_1 = level3 ("*" | "/") level4_1 | level4_1
level2_1 = level2 ("+" | "-") level3_1 | level3_1
level0 = level0 ";" level1 | level1

This may conflict with the Python way of assigning multiple variables:

a, b = 1, 2

Answer 3

Aggregating from comments (credits goes to @Stef and @ErikEidt).

Q1: The parser doesn't help in this case. There are 3 ways out of it:

1. add the expresion non-terminal to the primary-expression non-terminal, (and this would yield an ambiguous grammar).

2. Give logical operators same precedance as assignment operators. This is a breaking change to all C programs (and any program written in one of the C-family language).

3. Borrow from Perl, use literal and and or for lower precedance.

Q2: that of the grammar.