feat(analyzer): add property and generator issue categories

This commit continues the work on issue categorization by introducing two new categories, giving users more fine-grained control over the analysis.

The new categories are:

- **`property_issues`**: Groups all diagnostics related to class properties, including access, assignment, visibility, and type compatibility.
- **`generator_issues`**: Groups all diagnostics related to PHP generators, such as `yield`, `yield from`, and generator return types.

These categories can be disabled in `mago.toml` to help tailor the analysis for specific projects.

Additionally, existing categories like `argument`, `redundancy`, and `impossibility` have been expanded to be more comprehensive.

Signed-off-by: azjezz <[email protected]>

Author: azjezz

crates/analyzer/src/code.rs

@@ -779,7 +779,7 @@ impl IssueCode {
         ]
     }
 
-    pub const fn get_argument_issue_codes() -> [Self; 14] {
+    pub const fn get_argument_issue_codes() -> [Self; 16] {
         [
             Self::DuplicateNamedArgument,
             Self::FalseArgument,
@@ -795,10 +795,12 @@ impl IssueCode {
             Self::PossiblyFalseArgument,
             Self::PossiblyInvalidArgument,
             Self::PossiblyNullArgument,
+            Self::TooFewArguments,
+            Self::TooManyArguments,
         ]
     }
 
-    pub const fn get_argument_issue_code_values() -> [&'static str; 14] {
+    pub const fn get_argument_issue_code_values() -> [&'static str; 16] {
         [
             "duplicate-named-argument",
             "false-argument",
@@ -814,6 +816,8 @@ impl IssueCode {
             "possibly-false-argument",
             "possibly-invalid-argument",
             "possibly-null-argument",
+            "too-few-arguments",
+            "too-many-arguments",
         ]
     }
 
@@ -840,6 +844,74 @@ impl IssueCode {
             "possibly-null-operand",
         ]
     }
+
+    pub const fn get_property_issue_codes() -> [Self; 14] {
+        [
+            Self::AmbiguousObjectPropertyAccess,
+            Self::IncompatiblePropertyType,
+            Self::InvalidPropertyAccess,
+            Self::InvalidPropertyAssignmentValue,
+            Self::InvalidPropertyRead,
+            Self::InvalidPropertyWrite,
+            Self::InvalidStaticPropertyAccess,
+            Self::MixedPropertyAccess,
+            Self::MixedPropertyTypeCoercion,
+            Self::NonExistentProperty,
+            Self::NullPropertyAccess,
+            Self::OverriddenPropertyAccess,
+            Self::PossiblyNullPropertyAccess,
+            Self::PropertyTypeCoercion,
+        ]
+    }
+
+    pub const fn get_property_issue_code_values() -> [&'static str; 14] {
+        [
+            "ambiguous-object-property-access",
+            "incompatible-property-type",
+            "invalid-property-access",
+            "invalid-property-assignment-value",
+            "invalid-property-read",
+            "invalid-property-write",
+            "invalid-static-property-access",
+            "mixed-property-access",
+            "mixed-property-type-coercion",
+            "non-existent-property",
+            "null-property-access",
+            "overridden-property-access",
+            "possibly-null-property-access",
+            "property-type-coercion",
+        ]
+    }
+
+    pub const fn get_generator_issue_codes() -> [Self; 10] {
+        [
+            Self::HiddenGeneratorReturn,
+            Self::InvalidGeneratorReturnType,
+            Self::InvalidYieldKeyType,
+            Self::InvalidYieldValueType,
+            Self::UnknownYieldFromIteratorType,
+            Self::YieldFromInvalidKeyType,
+            Self::YieldFromInvalidSendType,
+            Self::YieldFromInvalidValueType,
+            Self::YieldFromNonIterable,
+            Self::YieldOutsideFunction,
+        ]
+    }
+
+    pub const fn get_generator_issue_code_values() -> [&'static str; 10] {
+        [
+            "hidden-generator-return",
+            "invalid-generator-return-type",
+            "invalid-yield-key-type",
+            "invalid-yield-value-type",
+            "unknown-yield-from-iterator-type",
+            "yield-from-invalid-key-type",
+            "yield-from-invalid-send-type",
+            "yield-from-invalid-value-type",
+            "yield-from-non-iterable",
+            "yield-outside-function",
+        ]
+    }
 }
 
 impl std::str::FromStr for IssueCode {

crates/analyzer/src/lib.rs

@@ -123,6 +123,14 @@ impl<'a> Analyzer<'a> {
             collector.add_disabled_codes(IssueCode::get_operand_issue_code_values());
         }
 
+        if !self.settings.property_issues {
+            collector.add_disabled_codes(IssueCode::get_property_issue_code_values());
+        }
+
+        if !self.settings.generator_issues {
+            collector.add_disabled_codes(IssueCode::get_generator_issue_code_values());
+        }
+
         let mut context = {
             Context::new(
                 self.interner,

crates/analyzer/src/settings.rs

@@ -48,6 +48,12 @@ pub struct Settings {
     /// Report all issues related to operands in expressions. Defaults to `true`.
     pub operand_issues: bool,
 
+    /// Report all issues related to properties and their usage. Defaults to `true`.
+    pub property_issues: bool,
+
+    /// Report all issues related to the use of generators. Defaults to `true`.
+    pub generator_issues: bool,
+
     /// Find and report expressions whose results are not used (e.g., `$a + $b;`). Defaults to `false`.
     pub find_unused_expressions: bool,
 
@@ -111,6 +117,8 @@ impl Settings {
             argument_issues: true,
             operand_issues: true,
             ambiguity_issues: true,
+            property_issues: true,
+            generator_issues: true,
             find_unused_expressions: false,
             find_unused_definitions: false,
             analyze_dead_code: false,

src/config/analyzer.rs

@@ -56,6 +56,12 @@ pub struct AnalyzeConfiguration {
     /// Report all issues related to operands in expressions.
     pub operand_issues: bool,
 
+    /// Report all issues related to properties and their usage.
+    pub property_issues: bool,
+
+    /// Report all issues related to the use of generators.
+    pub generator_issues: bool,
+
     /// Whether to find unused expressions.
     pub find_unused_expressions: bool,
 
@@ -101,6 +107,8 @@ impl AnalyzeConfiguration {
             template_issues: self.template_issues,
             argument_issues: self.argument_issues,
             operand_issues: self.operand_issues,
+            property_issues: self.property_issues,
+            generator_issues: self.generator_issues,
             analyze_dead_code: self.analyze_dead_code,
             find_unused_definitions: self.find_unused_definitions,
             find_unused_expressions: self.find_unused_expressions,
@@ -137,6 +145,8 @@ impl ConfigurationEntry for AnalyzeConfiguration {
             .set_default("analyze.template_issues", defaults.template_issues)?
             .set_default("analyze.argument_issues", defaults.argument_issues)?
             .set_default("analyze.operand_issues", defaults.operand_issues)?
+            .set_default("analyze.property_issues", defaults.property_issues)?
+            .set_default("analyze.generator_issues", defaults.generator_issues)?
             .set_default("analyze.find_unused_definitions", defaults.find_unused_definitions)?
             .set_default("analyze.find_unused_expressions", defaults.find_unused_expressions)?
             .set_default("analyze.analyze_dead_code", defaults.analyze_dead_code)?
@@ -169,6 +179,8 @@ impl Default for AnalyzeConfiguration {
             template_issues: defaults.template_issues,
             argument_issues: defaults.argument_issues,
             operand_issues: defaults.operand_issues,
+            property_issues: defaults.property_issues,
+            generator_issues: defaults.generator_issues,
             find_unused_expressions: defaults.find_unused_expressions,
             find_unused_definitions: defaults.find_unused_definitions,
             analyze_dead_code: defaults.analyze_dead_code,