Struct php_parser_rs::parser::ast::modifiers::MethodModifierGroup

source ·

#[repr(transparent)]pub struct MethodModifierGroup {
    pub modifiers: Vec<MethodModifier>,
}

Fields§

§modifiers: Vec<MethodModifier>

Implementations§

source §

pub fn has_abstract(&self) -> bool

Examples found in repository ?

src/parser/internal/functions.rs (line 253)

pub fn method(
    state: &mut State,
    r#type: MethodType,
    modifiers: MethodModifierGroup,
    class_name: &str,
) -> ParseResult<Method> {
    let comments = state.stream.comments();
    let attributes = state.get_attributes();
    let function = utils::skip(state, TokenKind::Function)?;

    let current = state.stream.current();
    let ampersand = if current.kind == TokenKind::Ampersand {
        state.stream.next();

        Some(current.span)
    } else {
        None
    };

    let name = identifiers::identifier_maybe_reserved(state)?;
    let has_body = match r#type {
        MethodType::Abstract => false,
        MethodType::Concrete => true,
        MethodType::DependingOnModifiers => !modifiers.has_abstract(),
    };

    if name.to_string().to_lowercase() == "__construct" {
        if has_body {
            let parameters = parameters::constructor_parameter_list(state, class_name)?;
            let body = MethodBody {
                comments: state.stream.comments(),
                left_brace: utils::skip_left_brace(state)?,
                statements: blocks::multiple_statements_until(state, &TokenKind::RightBrace)?,
                right_brace: utils::skip_right_brace(state)?,
            };

            return Ok(Method::ConcreteConstructor(ConcreteConstructor {
                comments,
                attributes,
                modifiers,
                function,
                ampersand,
                name,
                parameters,
                body,
            }));
        } else {
            let parameters = parameters::function_parameter_list(state)?;
            let semicolon = utils::skip_semicolon(state)?;

            return Ok(Method::AbstractConstructor(AbstractConstructor {
                comments,
                attributes,
                modifiers,
                function,
                ampersand,
                name,
                parameters,
                semicolon,
            }));
        }
    }

    let parameters = parameters::function_parameter_list(state)?;
    let return_type = if state.stream.current().kind == TokenKind::Colon {
        Some(ReturnType {
            colon: utils::skip_colon(state)?,
            data_type: data_type::data_type(state)?,
        })
    } else {
        None
    };

    if has_body {
        Ok(Method::Concrete(ConcreteMethod {
            comments,
            attributes,
            modifiers,
            function,
            ampersand,
            name,
            parameters,
            return_type,
            body: MethodBody {
                comments: state.stream.comments(),
                left_brace: utils::skip_left_brace(state)?,
                statements: blocks::multiple_statements_until(state, &TokenKind::RightBrace)?,
                right_brace: utils::skip_right_brace(state)?,
            },
        }))
    } else {
        Ok(Method::Abstract(AbstractMethod {
            comments,
            attributes,
            modifiers,
            function,
            ampersand,
            name,
            parameters,
            return_type,
            semicolon: utils::skip_semicolon(state)?,
        }))
    }
}

source

pub fn get_abstract(&self) -> Option<&MethodModifier>

Examples found in repository ?

src/parser/internal/classes.rs (line 197)

fn member(state: &mut State, abstract_class: bool, class_name: &str) -> ParseResult<ClassMember> {
    let has_attributes = attributes::gather_attributes(state)?;

    if !has_attributes && state.stream.current().kind == TokenKind::Use {
        return traits::usage(state).map(ClassMember::TraitUsage);
    }

    if state.stream.current().kind == TokenKind::Var {
        return properties::parse_var(state, class_name).map(ClassMember::VariableProperty);
    }

    let modifiers = modifiers::collect(state)?;

    if state.stream.current().kind == TokenKind::Const {
        return classish(state, modifiers::constant_group(modifiers)?).map(ClassMember::Constant);
    }

    if state.stream.current().kind == TokenKind::Function {
        let method = method(
            state,
            MethodType::DependingOnModifiers,
            modifiers::method_group(modifiers)?,
            class_name,
        )?;

        match method {
            Method::Abstract(method) => {
                if !abstract_class {
                    return Err(ParseError::AbstractModifierOnNonAbstractClassMethod(
                        method.modifiers.get_abstract().unwrap().span(),
                    ));
                }

                return Ok(ClassMember::AbstractMethod(method));
            }
            Method::Concrete(method) => {
                return Ok(ClassMember::ConcreteMethod(method));
            }
            Method::AbstractConstructor(ctor) => {
                if !abstract_class {
                    return Err(ParseError::AbstractModifierOnNonAbstractClassMethod(
                        ctor.modifiers.get_abstract().unwrap().span(),
                    ));
                }

                return Ok(ClassMember::AbstractConstructor(ctor));
            }
            Method::ConcreteConstructor(ctor) => {
                return Ok(ClassMember::ConcreteConstructor(ctor));
            }
        }
    }

    // e.g: public static
    let modifiers = modifiers::property_group(modifiers)?;

    properties::parse(state, class_name, modifiers).map(ClassMember::Property)
}