update dependencies

Cargo.toml

@@ -1,23 +1,23 @@
 [package]
 name = "php-literal-parser"
 description = "parser for php literals"
-version = "0.5.1"
+version = "0.6.0"
 authors = ["Robin Appelman <robin@icewind.nl>"]
 edition = "2018"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/icewind1991/php-literal-parser"
 documentation = "https://docs.rs/php-literal-parser"
-rust-version = "1.56"
+rust-version = "1.70"
 
 [dependencies]
-logos = "0.12.1"
+logos = "0.14.0"
-thiserror = "1.0.38"
+thiserror = "1.0.57"
-memchr = "2.5.0"
+memchr = "2.7.1"
-serde = "1.0.152"
+serde = "1.0.197"
-miette = "5.5.0"
+miette = "7.2.0"
-parse-display = "0.8.0"
+parse-display = "0.9.0"
 
 [dev-dependencies]
 maplit = "1.0.2"
-serde_derive = "1.0.152"
+serde_derive = "1.0.197"
-miette = { version = "5.5.0", features = ["fancy"] }
+miette = { version = "7.2.0", features = ["fancy"] }

flake.lock

@@ -2,16 +2,16 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1674902473,
+        "lastModified": 1710162809,
-        "narHash": "sha256-MdKJeeDTjCtmoVPWLEDg10jgknt6rqTO3c1WeNQtho4=",
+        "narHash": "sha256-i2R2bcnQp+85de67yjgZVvJhd6rRnJbSYNpGmB6Leb8=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "548896f4d9f7db2f7205d82727d6c03c86d2f896",
+        "rev": "ddcd7598b2184008c97e6c9c6a21c5f37590b8d2",
         "type": "github"
       },
       "original": {
         "id": "nixpkgs",
-        "ref": "release-22.11",
+        "ref": "release-23.11",
         "type": "indirect"
       }
     },
@@ -21,13 +21,31 @@
         "utils": "utils"
       }
     },
-    "utils": {
+    "systems": {
       "locked": {
-        "lastModified": 1667395993,
+        "lastModified": 1681028828,
-        "narHash": "sha256-nuEHfE/LcWyuSWnS8t12N1wc105Qtau+/OdUAjtQ0rA=",
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    },
+    "utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1710146030,
+        "narHash": "sha256-SZ5L6eA7HJ/nmkzGG7/ISclqe6oZdOZTNoesiInkXPQ=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "5aed5285a952e0b949eb3ba02c12fa4fcfef535f",
+        "rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a",
         "type": "github"
       },
       "original": {

flake.nix

@@ -1,7 +1,7 @@
 {
   inputs = {
     utils.url = "github:numtide/flake-utils";
-    nixpkgs.url = "nixpkgs/release-22.11";
+    nixpkgs.url = "nixpkgs/release-23.11";
   };
 
   outputs = {

src/error.rs

@@ -298,7 +298,7 @@ impl<'source> ExpectToken<'source> for SpannedToken<'source> {
 fn map_span(span: &Span) -> SourceSpan {
     SourceSpan::new(
         SourceOffset::from(span.start),
-        SourceOffset::from(span.end - span.start),
+        span.end - span.start,
     )
 }
 

src/lexer.rs

@@ -3,6 +3,9 @@ use parse_display::Display;
 use std::fmt::{Debug, Formatter};
 
 #[derive(Logos, Debug, PartialEq, Clone, Copy, Display)]
+#[logos(skip r"(#|//)[^\n]*")]
+#[logos(skip r"/\*([^*]|\*[^/])+\*/")]
+#[logos(skip r"[ \t\n\f]+")]
 pub enum Token {
     #[token("array")]
     #[display("'array'")]
@@ -43,11 +46,6 @@ pub enum Token {
     #[token(";")]
     #[display("';'")]
     SemiColon,
-    #[error]
-    #[regex(r"(#|//)[^\n]*", logos::skip)]
-    #[regex(r"/\*([^*]|\*[^/])+\*/", logos::skip)]
-    #[regex(r"[ \t\n\f]+", logos::skip)]
-    #[display("error")]
     Error,
 }
 
@@ -70,72 +68,72 @@ fn test_lex() {
     "###;
     let mut lex = Token::lexer(source);
 
-    assert_eq!(lex.next(), Some(Token::Array));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Array));
-    assert_eq!(lex.next(), Some(Token::BracketOpen));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::BracketOpen));
 
-    assert_eq!(lex.next(), Some(Token::LiteralString));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::LiteralString));
-    assert_eq!(lex.next(), Some(Token::Arrow));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Arrow));
-    assert_eq!(lex.next(), Some(Token::LiteralString));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::LiteralString));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
 
-    assert_eq!(lex.next(), Some(Token::LiteralString));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::LiteralString));
-    assert_eq!(lex.next(), Some(Token::Arrow));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Arrow));
-    assert_eq!(lex.next(), Some(Token::LiteralString));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::LiteralString));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
 
-    assert_eq!(lex.next(), Some(Token::LiteralString));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::LiteralString));
-    assert_eq!(lex.next(), Some(Token::Arrow));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Arrow));
-    assert_eq!(lex.next(), Some(Token::LiteralString));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::LiteralString));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
 
-    assert_eq!(lex.next(), Some(Token::Integer));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Integer));
-    assert_eq!(lex.next(), Some(Token::Arrow));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Arrow));
-    assert_eq!(lex.next(), Some(Token::Integer));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Integer));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
 
-    assert_eq!(lex.next(), Some(Token::LiteralString));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::LiteralString));
-    assert_eq!(lex.next(), Some(Token::Arrow));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Arrow));
-    assert_eq!(lex.next(), Some(Token::SquareOpen));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::SquareOpen));
 
-    assert_eq!(lex.next(), Some(Token::LiteralString));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::LiteralString));
-    assert_eq!(lex.next(), Some(Token::Arrow));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Arrow));
-    assert_eq!(lex.next(), Some(Token::LiteralString));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::LiteralString));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
 
-    assert_eq!(lex.next(), Some(Token::SquareClose));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::SquareClose));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
 
-    assert_eq!(lex.next(), Some(Token::LiteralString));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::LiteralString));
-    assert_eq!(lex.next(), Some(Token::Arrow));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Arrow));
-    assert_eq!(lex.next(), Some(Token::SquareOpen));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::SquareOpen));
-    assert_eq!(lex.next(), Some(Token::Integer));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Integer));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
-    assert_eq!(lex.next(), Some(Token::Integer));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Integer));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
-    assert_eq!(lex.next(), Some(Token::Integer));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Integer));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
-    assert_eq!(lex.next(), Some(Token::Integer));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Integer));
-    assert_eq!(lex.next(), Some(Token::SquareClose));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::SquareClose));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
 
-    assert_eq!(lex.next(), Some(Token::LiteralString));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::LiteralString));
-    assert_eq!(lex.next(), Some(Token::Arrow));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Arrow));
-    assert_eq!(lex.next(), Some(Token::Bool));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Bool));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
 
-    assert_eq!(lex.next(), Some(Token::LiteralString));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::LiteralString));
-    assert_eq!(lex.next(), Some(Token::Arrow));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Arrow));
-    assert_eq!(lex.next(), Some(Token::Integer));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Integer));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
 
-    assert_eq!(lex.next(), Some(Token::LiteralString));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::LiteralString));
-    assert_eq!(lex.next(), Some(Token::Arrow));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Arrow));
-    assert_eq!(lex.next(), Some(Token::Null));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Null));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
 
-    assert_eq!(lex.next(), Some(Token::BracketClose));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::BracketClose));
 
-    assert_eq!(lex.next(), None);
+    assert_eq!(lex.next().transpose().unwrap(), None);
 }
 
 #[test]
@@ -143,23 +141,23 @@ fn test_lex_int() {
     let source = r###"0,123,0x123,0123,0b111,12_34_56"###;
     let mut lex = Token::lexer(source);
 
-    assert_eq!(lex.next(), Some(Token::Integer));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Integer));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
 
-    assert_eq!(lex.next(), Some(Token::Integer));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Integer));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
 
-    assert_eq!(lex.next(), Some(Token::Integer));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Integer));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
 
-    assert_eq!(lex.next(), Some(Token::Integer));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Integer));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
 
-    assert_eq!(lex.next(), Some(Token::Integer));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Integer));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
 
-    assert_eq!(lex.next(), Some(Token::Integer));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Integer));
-    assert_eq!(lex.next(), None);
+    assert_eq!(lex.next().transpose().unwrap(), None);
 }
 
 #[test]
@@ -167,23 +165,23 @@ fn test_lex_float() {
     let source = r###".1,123.0,123e1,123e+1,123e-1,1_23.456"###;
     let mut lex = Token::lexer(source);
 
-    assert_eq!(lex.next(), Some(Token::Float));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Float));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
 
-    assert_eq!(lex.next(), Some(Token::Float));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Float));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
 
-    assert_eq!(lex.next(), Some(Token::Float));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Float));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
 
-    assert_eq!(lex.next(), Some(Token::Float));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Float));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
 
-    assert_eq!(lex.next(), Some(Token::Float));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Float));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
 
-    assert_eq!(lex.next(), Some(Token::Float));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Float));
-    assert_eq!(lex.next(), None);
+    assert_eq!(lex.next().transpose().unwrap(), None);
 }
 
 #[test]
@@ -198,15 +196,15 @@ fn test_lex_comments() {
     "###;
     let mut lex = Token::lexer(source);
 
-    assert_eq!(lex.next(), Some(Token::Array));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Array));
-    assert_eq!(lex.next(), Some(Token::BracketOpen));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::BracketOpen));
 
-    assert_eq!(lex.next(), Some(Token::LiteralString));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::LiteralString));
-    assert_eq!(lex.next(), Some(Token::Arrow));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Arrow));
-    assert_eq!(lex.next(), Some(Token::LiteralString));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::LiteralString));
-    assert_eq!(lex.next(), Some(Token::Comma));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::Comma));
 
-    assert_eq!(lex.next(), Some(Token::BracketClose));
+    assert_eq!(lex.next().transpose().unwrap(), Some(Token::BracketClose));
 }
 
 #[derive(Clone)]
@@ -247,7 +245,7 @@ impl<'source> Iterator for TokenStream<'source> {
     type Item = SpannedToken<'source>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let token = self.lexer.next()?;
+        let token = self.lexer.next()?.unwrap_or(Token::Error);
         Some(SpannedToken {
             token,
             span: self.lexer.span(),