Method to_subject_text

src/subject_expr.rs:262–342

Return the raw text representation of this expression. This is used as a bridge while callers are migrated: they can parse a string into `SubjectExpr`, match on it, and still pass the original text to functions that haven't been converted yet.

(&self)

    /// parse a string into `SubjectExpr`, match on it, and still pass
    /// the original text to functions that haven't been converted yet.
    pub fn to_subject_text(&self) -> String {
        match self {
            SubjectExpr::This => "$this".to_string(),
            SubjectExpr::SelfKw => "self".to_string(),
            SubjectExpr::StaticKw => "static".to_string(),
            SubjectExpr::Parent => "parent".to_string(),
            SubjectExpr::Variable(v) => v.clone(),
            SubjectExpr::PropertyChain { base, property } => {
                format!("{}->{}", base.to_subject_text(), property)
            }
            SubjectExpr::CallExpr { callee, args_text } => {
                // Wrap the callee in parentheses when it is an
                // expression form that is not naturally callable by
                // name.  Without this, `PropertyChain { $this, "prop" }`
                // serialises as `$this->prop(args)` (a method call)
                // instead of the correct `($this->prop)(args)` (invoke
                // property as callable via __invoke).
                let needs_parens = matches!(
                    callee.as_ref(),
                    SubjectExpr::PropertyChain { .. }
                        | SubjectExpr::This
                        | SubjectExpr::SelfKw
                        | SubjectExpr::StaticKw
                        | SubjectExpr::Parent
                        | SubjectExpr::ArrayAccess { .. }
                        | SubjectExpr::InlineArray { .. }
                        | SubjectExpr::CallExpr { .. }
                );
                if needs_parens {
                    format!("({})({})", callee.to_subject_text(), args_text)
                } else {
                    format!("{}({})", callee.to_subject_text(), args_text)
                }
            }
            SubjectExpr::MethodCall { base, method } => {
                format!("{}->{}", base.to_subject_text(), method)
            }
            SubjectExpr::StaticMethodCall { class, method } => {
                format!("{}::{}", class, method)
            }
            SubjectExpr::StaticAccess { class, member } => {
                format!("{}::{}", class, member)
            }
            SubjectExpr::NewExpr { class_name } => {
                format!("new {}", class_name)
            }
            SubjectExpr::ClassName(name) => name.clone(),
            SubjectExpr::FunctionCall(name) => name.clone(),
            SubjectExpr::ArrayAccess { base, segments } => {
                let mut s = base.to_subject_text();
                for seg in segments {
                    match seg {
                        BracketSegment::StringKey(k) => {
                            s.push_str(&format!("['{}']", k));
                        }
                        BracketSegment::ElementAccess => {
                            s.push_str("[]");
                        }