mago-syntax 1.20.1

A correct, fast, and memory-efficient PHP syntax implementation, including Lexer, Parser, AST, and utilities for Mago.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

use crate::ast::BinaryOperator;
use crate::ast::Expression;
use crate::ast::Literal;
use crate::ast::UnaryPrefixOperator;

/// Determine if an expression is truthy.
///
/// This function will return true if the expression is truthy, and false otherwise.
///
/// When this function returns true, it does not necessarily mean that the expression will always evaluate to true.
/// It simply means that the expression is truthy in the context of PHP.
#[inline]
#[must_use]
pub fn is_truthy(expression: &Expression<'_>) -> bool {
    match &expression {
        Expression::Parenthesized(parenthesized) => is_truthy(parenthesized.expression),
        Expression::Literal(Literal::True(_)) => true,
        Expression::AnonymousClass(_) => true,
        Expression::Closure(_) => true,
        Expression::ArrowFunction(_) => true,
        Expression::Array(array) => !array.elements.is_empty(),
        Expression::LegacyArray(array) => !array.elements.is_empty(),
        Expression::PartialApplication(_) => true,
        Expression::Binary(operation) => match operation.operator {
            BinaryOperator::Or(_) | BinaryOperator::LowOr(_) => is_truthy(operation.lhs) || is_truthy(operation.rhs),
            BinaryOperator::And(_) | BinaryOperator::LowAnd(_) => is_truthy(operation.lhs) && is_truthy(operation.rhs),
            BinaryOperator::NullCoalesce(_) => is_truthy(operation.lhs),
            BinaryOperator::LowXor(_) => is_truthy(operation.lhs) ^ is_truthy(operation.rhs),
            _ => false,
        },
        Expression::UnaryPrefix(operation) => match operation.operator {
            UnaryPrefixOperator::ErrorControl(_) => is_truthy(operation.operand),
            UnaryPrefixOperator::Reference(_) => is_truthy(operation.operand),
            UnaryPrefixOperator::Not(_) => is_falsy(operation.operand),
            _ => false,
        },
        Expression::Assignment(assignment) => is_truthy(assignment.rhs),
        _ => false,
    }
}

/// Determine if an expression is falsy.
///
/// This function will return true if the expression is falsy, and false otherwise.
///
/// When this function returns false, it does not mean that the expression is truthy,
/// it just means that we could not determine if the expression is falsy.
#[inline]
#[must_use]
pub fn is_falsy(expression: &Expression<'_>) -> bool {
    match &expression {
        Expression::Parenthesized(parenthesized) => is_falsy(parenthesized.expression),
        Expression::Literal(Literal::False(_) | Literal::Null(_)) => true,
        Expression::Array(array) => array.elements.is_empty(),
        Expression::LegacyArray(array) => array.elements.is_empty(),
        Expression::Assignment(assignment) => is_falsy(assignment.rhs),
        Expression::Binary(operation) => match operation.operator {
            BinaryOperator::Or(_) | BinaryOperator::LowOr(_) => is_falsy(operation.lhs) && is_falsy(operation.rhs),
            BinaryOperator::And(_) | BinaryOperator::LowAnd(_) => is_falsy(operation.lhs) || is_falsy(operation.rhs),
            BinaryOperator::NullCoalesce(_) => is_falsy(operation.lhs) && is_falsy(operation.rhs),
            BinaryOperator::LowXor(_) => is_falsy(operation.lhs) ^ is_falsy(operation.rhs),
            _ => false,
        },
        Expression::UnaryPrefix(operation) => match operation.operator {
            UnaryPrefixOperator::ErrorControl(_) => is_falsy(operation.operand),
            UnaryPrefixOperator::Reference(_) => is_falsy(operation.operand),
            UnaryPrefixOperator::Not(_) => is_truthy(operation.operand),
            _ => false,
        },
        _ => false,
    }
}