chore: report intersection with literal types (#20)

src/parser/internal/definition/type.rs

@@ -434,6 +434,13 @@ fn intersection(
         );
     }
 
+    if type_definition.is_literal() {
+        crate::parser_report!(
+            state,
+            literal_type_cannot_be_used_in_intersection(&type_definition, last_ampersand)
+        );
+    }
+
     let mut type_definitions = vec![type_definition];
 
     loop {
@@ -481,6 +488,13 @@ fn intersection(
                 );
             }
 
+            if type_definition.is_literal() {
+                crate::parser_report!(
+                    state,
+                    literal_type_cannot_be_used_in_intersection(&type_definition, last_ampersand)
+                );
+            }
+
             type_definition
         };
 

src/parser/issue.rs

@@ -687,6 +687,20 @@ pub enum ParserIssueCode {
     /// - Remove the empty type template
     /// - Add a type template
     ExpectedAtLeastOneTypeInTemplateGroup = 46,
+
+    /// Literal type cannot be used in intersection ( code = 47 )
+    ///
+    /// Example:
+    ///
+    /// ```ara
+    /// function foo(Foo&null $bar): void {}
+    /// ```
+    ///
+    /// Possible solution(s):
+    ///
+    /// - Use a different type (instead of `null`)
+    /// - Change the intersection to a union
+    LiteralTypeCannotBeUsedInIntersection = 47,
 }
 
 pub(crate) fn php_opening_tag_not_supported(state: &ParserState, token: &Token) -> Issue {
@@ -1036,6 +1050,28 @@ pub(crate) fn scalar_type_cannot_be_used_in_intersection(
     .with_help("try using a different type for the intersection.")
 }
 
+pub(crate) fn literal_type_cannot_be_used_in_intersection(
+    state: &ParserState,
+    type_definition: &TypeDefinition,
+    ampersand: usize,
+) -> Issue {
+    let origin = state.source.name();
+
+    Issue::error(
+        ParserIssueCode::LiteralTypeCannotBeUsedInIntersection,
+        format!(
+            "literal type `{}` cannot be used in an intersection",
+            &type_definition,
+        ),
+        origin,
+        type_definition.initial_position(),
+        type_definition.final_position(),
+    )
+    .with_annotation(Annotation::new(origin, ampersand, ampersand + 1))
+    .with_note("a literal type is either a literal integer, a literal float, a literal string, `false`, `true`, or `null`.")
+    .with_help("try using a different type for the intersection.")
+}
+
 pub(crate) fn readonly_property_cannot_be_static(
     state: &ParserState,
     class_name: Option<&Identifier>,

tests/samples/0105/code.ara

@@ -0,0 +1,4 @@
+
+function foo(null&Bar $bar): mixed {}
+
+function foo(Bar&null $bar): mixed {}

tests/samples/0105/error.txt

@@ -0,0 +1,20 @@
+error[P0047]: literal type `null` cannot be used in an intersection
+  --> 0105/code.ara:2:14
+  |
+2 | function foo(null&Bar $bar): mixed {}
+  |              ^^^^-
+  |              |    
+  |              literal type `null` cannot be used in an intersection
+  |
+  = note: a literal type is either a literal integer, a literal float, a literal string, `false`, `true`, or `null`.
+  = help: try using a different type for the intersection.
+
+error[P0047]: literal type `null` cannot be used in an intersection
+  --> 0105/code.ara:4:18
+  |
+4 | function foo(Bar&null $bar): mixed {}
+  |                 -^^^^ literal type `null` cannot be used in an intersection
+  |
+  = note: a literal type is either a literal integer, a literal float, a literal string, `false`, `true`, or `null`.
+  = help: try using a different type for the intersection.
+