Lexer+Parser: Add support for conditional callable parameters in docs

pxp-lang · Dec 19, 2024 · 71c1972 · 71c1972
1 parent 67643ee
commit 71c1972
Show file tree

Hide file tree

Showing 4 changed files with 62 additions and 5 deletions.
diff --git a/crates/inference/src/generator.rs b/crates/inference/src/generator.rs
@@ -487,7 +487,9 @@ fn bytestring_type(ty: &Type<Name>) -> Type<ByteString> {
             then: Box::new(bytestring_type(then)),
             otherwise: Box::new(bytestring_type(otherwise)),
         },
+        Type::Conditional { .. } => todo!(),
         Type::This => Type::This,
+        Type::ValueOf => Type::ValueOf,
         Type::Missing => Type::Missing,
     }
 }
diff --git a/crates/lexer/src/lib.rs b/crates/lexer/src/lib.rs
@@ -423,6 +423,14 @@ impl<'a> Lexer<'a> {
                             self.source.span_range(self.source.span()),
                         )
                     }
+                    b"value" if &self.source.read(3) == b"-of" => {
+                        self.source.skip(3);
+
+                        (
+                            self.source.span(),
+                            self.source.span_range(self.source.span()),
+                        )
+                    }
                     _ => (
                         self.source.span(),
                         self.source.span_range(self.source.span()),

diff --git a/crates/parser/src/internal/data_type.rs b/crates/parser/src/internal/data_type.rs
@@ -381,6 +381,44 @@ impl<'a> Parser<'a> {
         r#type
     }
 
+    fn parse_docblock_conditional(&mut self, lhs: Type<Name>) -> Type<Name> {
+        self.skip(TokenKind::PhpDocIs);
+        self.skip_doc_eol();
+
+        let negated = if self.current_kind() == TokenKind::PhpDocNot {
+            self.next();
+            true
+        } else {
+            false
+        };
+
+        let target_type = self.parse_docblock_type();
+
+        self.skip_doc_eol();
+
+        self.skip(TokenKind::Question);
+
+        self.skip_doc_eol();
+
+        let if_type = self.parse_docblock_type();
+
+        self.skip_doc_eol();
+
+        self.skip(TokenKind::Colon);
+
+        self.skip_doc_eol();
+
+        let else_type = self.parse_docblock_subparse();
+
+        Type::Conditional {
+            subject: Box::new(lhs),
+            negated,
+            target: Box::new(target_type),
+            then: Box::new(if_type),
+            otherwise: Box::new(else_type),
+        }
+    }
+
     fn parse_docblock_conditional_for_parameter(&mut self) -> Type<Name> {
         let parameter = self.current_symbol_as_bytestring();
 
@@ -438,13 +476,11 @@ impl<'a> Parser<'a> {
                     return Type::Missing;
                 }
 
-                if self.current_kind() == TokenKind::Identifier && self.current_symbol() == b"is" {
-                    todo!("parse docblock conditional type");
-                }
-
                 self.skip_doc_eol();
 
-                if self.current_kind() == TokenKind::Pipe {
+                if self.current_kind() == TokenKind::PhpDocIs {
+                    self.parse_docblock_conditional(r#type)
+                } else if self.current_kind() == TokenKind::Pipe {
                     self.parse_docblock_subparse_union(r#type)
                 } else if self.current_kind() == TokenKind::Ampersand {
                     self.parse_docblock_subparse_intersection(r#type)
@@ -559,6 +595,7 @@ impl<'a> Parser<'a> {
                     b"array" => Some(Type::Array),
                     b"callable" => Some(Type::Callable),
                     b"array-key" if parser.is_in_docblock() => Some(Type::ArrayKey),
+                    b"value-of" if parser.is_in_docblock() => Some(Type::ValueOf),
                     _ => {
                         let id = parser.id();
 

diff --git a/crates/type/src/lib.rs b/crates/type/src/lib.rs
@@ -38,6 +38,14 @@ pub enum Type<N: Debug + Display> {
         then: Box<Type<N>>,
         otherwise: Box<Type<N>>,
     },
+    Conditional {
+        subject: Box<Type<N>>,
+        negated: bool,
+        target: Box<Type<N>>,
+        then: Box<Type<N>>,
+        otherwise: Box<Type<N>>,
+    },
+    ValueOf,
     This,
     Missing,
 }
@@ -122,6 +130,7 @@ impl<N: Debug + Display> Type<N> {
 impl<N: Debug + Display> Display for Type<N> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
+            Type::ValueOf => write!(f, "value-of"),
             Type::Named(inner) => write!(f, "{}", inner),
             Type::Generic(inner, templates) => {
                 write!(
@@ -202,6 +211,7 @@ impl<N: Debug + Display> Display for Type<N> {
                     otherwise
                 )
             }
+            Type::Conditional { .. } => todo!(),
             Type::Missing => write!(f, "<missing>"),
         }
     }