Struct AnalysisResults 

pub struct AnalysisResults {
    pub strings: HashSet<(StringIdentifier, String)>,
    pub program: Program,
    pub parse_error: Option<Issue>,
    pub names: HashSet<(usize, (StringIdentifier, bool))>,
    pub formatted: Option<String>,
    pub semantic_issues: IssueCollection,
    pub linter_issues: IssueCollection,
}

Represents the result of analyzing and formatting PHP code.

This struct encapsulates various aspects of the PHP code analysis process, providing detailed insights into the source code, including:

• Interned strings used in the code.
• The resulting AST (Program) after parsing.
• An optional parse error if the code was invalid.
• Resolved name information (e.g., whether a name was imported).
• A collection of semantic issues found during analysis.
• A collection of linter issues found during linting (according to Settings).
• Optionally, a formatted version of the code if no parse error was encountered.

Note: This struct is serialized into JSON (via serde) for use in WebAssembly and browser environments. For direct Rust usage, it can be used as-is in a native context.

Fields

strings: HashSet<(StringIdentifier, String)>

A set of interned strings used in the source code.

Each string is represented as a tuple containing a StringIdentifier and the actual string value.

program: Program

The abstract syntax tree (AST) resulting from parsing the source code.

If parse_error is Some, this AST may be incomplete or invalid.

parse_error: Option<Issue>

An optional parse error, if one occurred during parsing.

If this is Some, then formatted will be None, because the code could not be validly parsed.

names: HashSet<(usize, (StringIdentifier, bool))>

The resolved names within the source code.

Each entry is a tuple (byte_offset, (identifier, imported)), where:

• byte_offset indicates where in the source the name is used,
• identifier is the StringIdentifier for the interned name,
• imported indicates whether this name was imported or locally declared.

formatted: Option<String>

The formatted version of the source code, if there were no parse errors.

This is produced by Mago’s internal formatter and is only set if parse_error is None.

semantic_issues: IssueCollection

A collection of semantic issues found during semantic analysis.

These might include invalid modifier usage, incorrect return types, or undefined variable references, among others.

linter_issues: IssueCollection

A collection of linter issues discovered based on the specified Settings.

Includes warnings or notices about potential coding standard violations, unused variables, or other recommended improvements.

Implementations

impl AnalysisResults

pub fn analyze( code: String, lint_settings: Settings, format_settings: FormatSettings, ) -> Self

Analyzes and (optionally) formats the provided PHP code.

This function performs the following steps:

1. Parsing via Module::build to generate an AST and detect syntax errors.
2. Semantic Analysis to resolve names and check for issues (e.g. undefined variables).
3. Linting according to the specified Settings.
4. Formatting using FormatSettings, provided no parse errors were found.

Arguments

• code - A String containing the PHP code to be analyzed.
• linter_settings - Configuration for which linter plugins and rules should run.
• format_settings - Configuration for how the code should be formatted.

Returns

Returns an AnalysisResults containing the AST, parse/semantic/linter issues, and formatted code (if no parse error).

Trait Implementations

impl Clone for AnalysisResults

fn clone(&self) -> AnalysisResults

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AnalysisResults

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Serialize for AnalysisResults

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.