ruff_python_parser 0.0.3

This is an internal component crate of Ruff
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use ruff_python_ast::token::TokenKind;
use ruff_python_ast::{self as ast, CmpOp, Expr, ExprContext, Number};
use ruff_text_size::{Ranged, TextRange};

use crate::error::RelaxedDecoratorError;

/// Set the `ctx` for `Expr::Id`, `Expr::Attribute`, `Expr::Subscript`, `Expr::Starred`,
/// `Expr::Tuple` and `Expr::List`. If `expr` is either `Expr::Tuple` or `Expr::List`,
/// recursively sets the `ctx` for their elements.
pub(super) fn set_expr_ctx(expr: &mut Expr, new_ctx: ExprContext) {
    match expr {
        Expr::Name(ast::ExprName { ctx, .. })
        | Expr::Attribute(ast::ExprAttribute { ctx, .. })
        | Expr::Subscript(ast::ExprSubscript { ctx, .. }) => *ctx = new_ctx,
        Expr::Starred(ast::ExprStarred { value, ctx, .. }) => {
            *ctx = new_ctx;
            set_expr_ctx(value, new_ctx);
        }
        Expr::UnaryOp(ast::ExprUnaryOp { operand, .. }) => {
            set_expr_ctx(operand, new_ctx);
        }
        Expr::List(ast::ExprList { elts, ctx, .. })
        | Expr::Tuple(ast::ExprTuple { elts, ctx, .. }) => {
            *ctx = new_ctx;
            for element in elts.iter_mut() {
                set_expr_ctx(element, new_ctx);
            }
        }
        _ => {}
    }
}

/// Converts a [`TokenKind`] into its corresponding [`CmpOp`].
///
/// `next` is only needed to distinguish `is not` and `not in`.
pub(super) const fn token_kind_to_cmp_op(
    current: TokenKind,
    next: Option<TokenKind>,
) -> Option<CmpOp> {
    Some(match (current, next) {
        (TokenKind::Is, Some(TokenKind::Not)) => CmpOp::IsNot,
        (TokenKind::Is, _) => CmpOp::Is,
        (TokenKind::Not, Some(TokenKind::In)) => CmpOp::NotIn,
        (TokenKind::In, _) => CmpOp::In,
        (TokenKind::EqEqual, _) => CmpOp::Eq,
        (TokenKind::NotEqual, _) => CmpOp::NotEq,
        (TokenKind::Less, _) => CmpOp::Lt,
        (TokenKind::LessEqual, _) => CmpOp::LtE,
        (TokenKind::Greater, _) => CmpOp::Gt,
        (TokenKind::GreaterEqual, _) => CmpOp::GtE,
        _ => return None,
    })
}

/// Helper for `parse_decorators` to determine if `expr` is a [`dotted_name`] from the decorator
/// grammar before Python 3.9.
///
/// Returns `Some((error, range))` if `expr` is not a `dotted_name`, or `None` if it is a `dotted_name`.
///
/// [`dotted_name`]: https://docs.python.org/3.8/reference/compound_stmts.html#grammar-token-dotted-name
pub(super) fn detect_invalid_pre_py39_decorator_node(
    expr: &Expr,
) -> Option<(RelaxedDecoratorError, TextRange)> {
    let description = match expr {
        Expr::Name(_) => return None,

        Expr::Attribute(attribute) => {
            return detect_invalid_pre_py39_decorator_node(&attribute.value);
        }

        Expr::Call(_) => return Some((RelaxedDecoratorError::CallExpression, expr.range())),

        Expr::NumberLiteral(number) => match &number.value {
            Number::Int(_) => "an int literal",
            Number::Float(_) => "a float literal",
            Number::Complex { .. } => "a complex literal",
        },

        Expr::BoolOp(_) => "boolean expression",
        Expr::BinOp(_) => "binary-operation expression",
        Expr::UnaryOp(_) => "unary-operation expression",
        Expr::Await(_) => "`await` expression",
        Expr::Lambda(_) => "lambda expression",
        Expr::If(_) => "conditional expression",
        Expr::Dict(_) => "a dict literal",
        Expr::Set(_) => "a set literal",
        Expr::List(_) => "a list literal",
        Expr::Tuple(_) => "a tuple literal",
        Expr::Starred(_) => "starred expression",
        Expr::Slice(_) => "slice expression",
        Expr::BytesLiteral(_) => "a bytes literal",
        Expr::StringLiteral(_) => "a string literal",
        Expr::EllipsisLiteral(_) => "an ellipsis literal",
        Expr::NoneLiteral(_) => "a `None` literal",
        Expr::BooleanLiteral(_) => "a boolean literal",
        Expr::ListComp(_) => "a list comprehension",
        Expr::SetComp(_) => "a set comprehension",
        Expr::DictComp(_) => "a dict comprehension",
        Expr::Generator(_) => "generator expression",
        Expr::Yield(_) => "`yield` expression",
        Expr::YieldFrom(_) => "`yield from` expression",
        Expr::Compare(_) => "comparison expression",
        Expr::FString(_) => "f-string",
        Expr::TString(_) => "t-string",
        Expr::Named(_) => "assignment expression",
        Expr::Subscript(_) => "subscript expression",
        Expr::IpyEscapeCommand(_) => "IPython escape command",
    };

    Some((RelaxedDecoratorError::Other(description), expr.range()))
}