koatl 0.2.2__tar.gz → 0.2.3__tar.gz

koatl-0.2.3/Cargo.lock

@@ -0,0 +1,218 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "ariadne"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36f5e3dca4e09a6f340a61a0e9c7b61e030c69fc27bf29d73218f7e5e3b7638f"
+dependencies = [
+ "unicode-width",
+ "yansi",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "indoc"
+version = "2.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
+
+[[package]]
+name = "koatl"
+version = "0.2.3"
+dependencies = [
+ "ariadne",
+ "koatl-core",
+ "once_cell",
+ "pyo3",
+]
+
+[[package]]
+name = "koatl-core"
+version = "0.1.0"
+dependencies = [
+ "ariadne",
+ "koatl-parser",
+ "once_cell",
+ "slotmap",
+]
+
+[[package]]
+name = "koatl-parser"
+version = "0.1.0"
+
+[[package]]
+name = "libc"
+version = "0.2.174"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "portable-atomic"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.95"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.25.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8970a78afe0628a3e3430376fc5fd76b6b45c4d43360ffd6cdd40bdde72b682a"
+dependencies = [
+ "indoc",
+ "libc",
+ "memoffset",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.25.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "458eb0c55e7ece017adeba38f2248ff3ac615e53660d7c71a238d7d2a01c7598"
+dependencies = [
+ "once_cell",
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.25.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7114fe5457c61b276ab77c5055f206295b812608083644a5c5b2640c3102565c"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.25.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8725c0a622b374d6cb051d11a0983786448f7785336139c3c94f5aa6bef7e50"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.25.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4109984c22491085343c05b0dbc54ddc405c3cf7b4374fc533f5c3313a572ccc"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "slotmap"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbff4acf519f630b3a3ddcfaea6c06b42174d9a44bc70c620e9ed1649d58b82a"
+dependencies = [
+ "version_check",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e502f78cdbb8ba4718f566c418c52bc729126ffd16baee5baa718cf25dd5a69a"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
+
+[[package]]
+name = "unicode-width"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
+
+[[package]]
+name = "unindent"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "yansi"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"

{koatl-0.2.2 → koatl-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: koatl
-Version: 0.2.2
+Version: 0.2.3
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{koatl-0.2.2 → koatl-0.2.3}/koatl/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "koatl"
-version = "0.2.2"
+version = "0.2.3"
 edition = "2021"
 
 [lib]

{koatl-0.2.2 → koatl-0.2.3}/koatl/src/emit_py.rs

@@ -512,21 +512,72 @@ trait PyLiteralExt<'src> {
 impl<'src> PyLiteralExt<'src> for PyLiteral<'src> {
     fn emit_py<'py>(&self, ctx: &PyCtx<'py, 'src>, span: &Span) -> PyTlResult<PyObject> {
         Ok(match self {
-            PyLiteral::Num(num) => {
+            PyLiteral::Int(num) => {
                 let num = num.replace('_', "");
-
                 match num.parse::<i128>() {
                     Ok(i) => ctx.ast_node("Constant", (i,), span)?,
-                    Err(_) => match num.parse::<f64>() {
-                        Ok(f) => ctx.ast_node("Constant", (f,), span)?,
-                        Err(_) => {
-                            return Err(PyTlErr {
-                                message: format!("Invalid number literal: {}", num),
-                                py_err: None,
-                                span: Some(*span),
-                            });
-                        }
-                    },
+                    Err(_) => {
+                        return Err(PyTlErr {
+                            message: format!("Invalid integer literal: {}", num),
+                            py_err: None,
+                            span: Some(*span),
+                        });
+                    }
+                }
+            }
+            PyLiteral::IntBin(num) => {
+                let num = num.replace('_', "");
+                // Keep the 0b prefix for Python compatibility
+                match i128::from_str_radix(&num[2..], 2) {
+                    Ok(i) => ctx.ast_node("Constant", (i,), span)?,
+                    Err(_) => {
+                        return Err(PyTlErr {
+                            message: format!("Invalid binary literal: {}", num),
+                            py_err: None,
+                            span: Some(*span),
+                        });
+                    }
+                }
+            }
+            PyLiteral::IntOct(num) => {
+                let num = num.replace('_', "");
+                // Keep the 0o prefix for Python compatibility
+                match i128::from_str_radix(&num[2..], 8) {
+                    Ok(i) => ctx.ast_node("Constant", (i,), span)?,
+                    Err(_) => {
+                        return Err(PyTlErr {
+                            message: format!("Invalid octal literal: {}", num),
+                            py_err: None,
+                            span: Some(*span),
+                        });
+                    }
+                }
+            }
+            PyLiteral::IntHex(num) => {
+                let num = num.replace('_', "");
+                // Keep the 0x prefix for Python compatibility
+                match i128::from_str_radix(&num[2..], 16) {
+                    Ok(i) => ctx.ast_node("Constant", (i,), span)?,
+                    Err(_) => {
+                        return Err(PyTlErr {
+                            message: format!("Invalid hexadecimal literal: {}", num),
+                            py_err: None,
+                            span: Some(*span),
+                        });
+                    }
+                }
+            }
+            PyLiteral::Float(num) => {
+                let num = num.replace('_', "");
+                match num.parse::<f64>() {
+                    Ok(f) => ctx.ast_node("Constant", (f,), span)?,
+                    Err(_) => {
+                        return Err(PyTlErr {
+                            message: format!("Invalid float literal: {}", num),
+                            py_err: None,
+                            span: Some(*span),
+                        });
+                    }
                 }
             }
             PyLiteral::Bool(b) => ctx.ast_node("Constant", (b,), span)?,

koatl-0.2.3/koatl/tests/parse/numbers.tl

@@ -0,0 +1,24 @@
+# Test various number literal formats
+
+# Integer literals
+let decimal_int = 42
+let decimal_int_underscore = 1_000_000
+
+# Binary literals
+let binary = 0b1010
+let binary_underscore = 0b1010_1010
+
+# Octal literals
+let octal = 0o755
+let octal_underscore = 0o7_5_5
+
+# Hexadecimal literals
+let hex = 0xFF
+let hex_underscore = 0xDEAD_BEEF
+
+# Float literals
+let float = 3.14
+let float_underscore = 3.14_159
+let scientific = 1.23e10
+let scientific_neg = 1.23e-10
+let scientific_plus = 1.23e+10

{koatl-0.2.2 → koatl-0.2.3}/koatl-core/src/ast.rs

@@ -50,7 +50,12 @@ pub type SIdent<'a> = Spanned<Ident<'a>>;
 
 #[derive(Debug, Clone)]
 pub enum Literal<'a> {
-    Num(Cow<'a, str>),
+    Float(Cow<'a, str>),
+    Int(Cow<'a, str>),
+    IntHex(Cow<'a, str>),
+    IntOct(Cow<'a, str>),
+    IntBin(Cow<'a, str>),
+
     Str(Cow<'a, str>),
     Bool(bool),
     None,

{koatl-0.2.2 → koatl-0.2.3}/koatl-core/src/ast_builder.rs

@@ -190,8 +190,8 @@ impl AstBuilder {
     }
 
     // Literal builders
-    pub fn num<'src>(&self, value: impl Into<Cow<'src, str>>) -> SExpr<'src> {
-        Expr::Literal(Literal::Num(value.into()).spanned(self.span)).spanned(self.span)
+    pub fn int<'src>(&self, value: impl Into<Cow<'src, str>>) -> SExpr<'src> {
+        Expr::Literal(Literal::Int(value.into()).spanned(self.span)).spanned(self.span)
     }
 
     pub fn str<'src>(&self, value: impl Into<Cow<'src, str>>) -> SExpr<'src> {

{koatl-0.2.2 → koatl-0.2.3}/koatl-core/src/lib.rs

@@ -120,11 +120,7 @@ pub fn transpile_to_py_ast<'src>(
 
     let mut py_ast = output.py_block;
 
-    let a = PyAstBuilder::new(Span {
-        start: 0,
-        end: 0,
-        context: (),
-    });
+    let a = PyAstBuilder::new(Span::new(0..0));
 
     if options.inject_prelude {
         py_ast.0.insert(
@@ -218,7 +214,7 @@ pub fn format_errs(errs: &TlErrs, filename: &str, src: &str) -> Vec<u8> {
     let mut writer = Vec::<u8>::new();
 
     for e in &errs.0 {
-        let range = e.span.map(|e| e.into_range()).unwrap_or(0..0);
+        let range = e.span.map(|e| e.start..e.end).unwrap_or(0..0);
 
         Report::build(ReportKind::Error, (filename.clone(), range.clone()))
             .with_config(ariadne::Config::new().with_index_type(ariadne::IndexType::Byte))
@@ -235,7 +231,7 @@ pub fn format_errs(errs: &TlErrs, filename: &str, src: &str) -> Vec<u8> {
                     label.clone()
                 };
 
-                Label::new((filename.clone(), span.into_range()))
+                Label::new((filename.clone(), span.start..span.end))
                     .with_message(msg)
                     .with_color(Color::Yellow)
             }))
@@ -256,12 +252,9 @@ pub fn parse_tl<'src>(src: &'src str) -> (Option<SExpr<'src>>, TlErrs) {
             .into_iter()
             .map(|e| TlErr {
                 kind: TlErrKind::Tokenize,
-                message: e.reason().to_string(),
-                span: Some(*e.span()),
-                contexts: e
-                    .contexts()
-                    .map(|(label, span)| (label.to_string(), *span))
-                    .collect(),
+                message: e.message.to_string(),
+                span: Some(e.span),
+                contexts: vec![],
             })
             .collect(),
     ));
@@ -278,12 +271,9 @@ pub fn parse_tl<'src>(src: &'src str) -> (Option<SExpr<'src>>, TlErrs) {
             .into_iter()
             .map(|e| TlErr {
                 kind: TlErrKind::Parse,
-                message: e.reason().to_string(),
-                span: Some(*e.span()),
-                contexts: e
-                    .contexts()
-                    .map(|(label, span)| (label.to_string(), *span))
-                    .collect(),
+                span: Some(e.0),
+                message: e.1,
+                contexts: vec![],
             })
             .collect(),
     ));

{koatl-0.2.2 → koatl-0.2.3}/koatl-core/src/lift_cst.rs

@@ -28,6 +28,19 @@ fn lift_fstr<'src, 'tok>(
                 Token::FstrContinue(s) => s.clone(),
                 _ => panic!("Expected FstrContinue token"),
             };
+
+            if fmt_expr.stmts.value.len() == 1 {
+                if let cst::Stmt::Expr { expr } = &fmt_expr.stmts.value[0].value {
+                    return (
+                        ast::FmtExpr {
+                            expr: expr.lift(),
+                            fmt: fmt_expr.fmt.as_ref().map(|(_, fmt)| fmt.lift()),
+                        },
+                        cont_str.spanned(cont.span),
+                    );
+                }
+            }
+
             (
                 ast::FmtExpr {
                     expr: fmt_expr.stmts.lift(),
@@ -37,6 +50,7 @@ fn lift_fstr<'src, 'tok>(
             )
         })
         .collect();
+
     ast::Expr::Fstr(begin_str.spanned(begin.span), fmt_parts)
 }
 
@@ -63,7 +77,11 @@ impl<'src> STokenExt<'src> for SToken<'src> {
 
     fn lift_as_literal(&self) -> Spanned<ast::Literal<'src>> {
         match &self.token {
-            Token::Num(n) => ast::Literal::Num(Cow::Borrowed(n)),
+            Token::Int(n) => ast::Literal::Int(Cow::Borrowed(n)),
+            Token::IntHex(n) => ast::Literal::IntHex(Cow::Borrowed(n)),
+            Token::IntOct(n) => ast::Literal::IntOct(Cow::Borrowed(n)),
+            Token::IntBin(n) => ast::Literal::IntBin(Cow::Borrowed(n)),
+            Token::Float(n) => ast::Literal::Float(Cow::Borrowed(n)),
             Token::Str(s) => ast::Literal::Str(s.clone().into()),
             Token::Bool(b) => ast::Literal::Bool(*b),
             Token::None => ast::Literal::None,

{koatl-0.2.2 → koatl-0.2.3}/koatl-core/src/main.rs

@@ -35,7 +35,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         },
         Err(errs) => {
             errs.0.into_iter().for_each(|e| {
-                let range = e.span.map(|e| e.into_range()).unwrap_or(0..0);
+                let range = e.span.map(|e| e.start..e.end).unwrap_or(0..0);
                 let err_prefix = match e.kind {
                     TlErrKind::Tokenize => "Tokenization Error: ",
                     TlErrKind::Parse => "Parser Error: ",
@@ -53,7 +53,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                             .with_color(Color::Red),
                     )
                     .with_labels(e.contexts.into_iter().map(|(label, span)| {
-                        Label::new((filename.clone(), span.into_range()))
+                        Label::new((filename.clone(), span.start..span.end))
                             .with_message(format!("while parsing this {label}"))
                             .with_color(Color::Yellow)
                     }))

{koatl-0.2.2 → koatl-0.2.3}/koatl-core/src/py/ast.rs

@@ -2,7 +2,7 @@ use std::borrow::Cow;
 
 use koatl_parser::lexer::Span;
 
-pub type PyIdent<'a> = Cow<'a, str>;
+pub type PyToken<'a> = Cow<'a, str>;
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum PyAccessCtx {
@@ -13,14 +13,14 @@ pub enum PyAccessCtx {
 
 #[derive(Debug, Clone)]
 pub struct PyImportAlias<'a> {
-    pub name: PyIdent<'a>,
-    pub as_name: Option<PyIdent<'a>>,
+    pub name: PyToken<'a>,
+    pub as_name: Option<PyToken<'a>>,
 }
 
 #[derive(Debug, Clone)]
 pub struct PyExceptHandler<'a> {
     pub typ: Option<SPyExpr<'a>>,
-    pub name: Option<PyIdent<'a>>,
+    pub name: Option<PyToken<'a>>,
     pub body: PyBlock<'a>,
 }
 
@@ -46,7 +46,7 @@ impl<'a> PyDecorators<'a> {
 
 #[derive(Debug, Clone)]
 pub struct PyFnDef<'a> {
-    pub name: PyIdent<'a>,
+    pub name: PyToken<'a>,
     pub args: Vec<PyArgDefItem<'a>>,
     pub body: PyBlock<'a>,
     pub decorators: PyDecorators<'a>,
@@ -55,7 +55,7 @@ pub struct PyFnDef<'a> {
 
 #[derive(Debug, Clone)]
 pub struct PyClassDef<'a> {
-    pub name: PyIdent<'a>,
+    pub name: PyToken<'a>,
     pub bases: Vec<PyCallItem<'a>>,
     pub body: PyBlock<'a>,
     pub decorators: PyDecorators<'a>,
@@ -71,10 +71,10 @@ pub enum PyStmt<'a> {
     Return(SPyExpr<'a>),
     Raise(Option<SPyExpr<'a>>),
     Assert(SPyExpr<'a>, Option<SPyExpr<'a>>),
-    Global(Vec<PyIdent<'a>>),
-    Nonlocal(Vec<PyIdent<'a>>),
+    Global(Vec<PyToken<'a>>),
+    Nonlocal(Vec<PyToken<'a>>),
     Import(Vec<PyImportAlias<'a>>),
-    ImportFrom(Option<PyIdent<'a>>, Vec<PyImportAlias<'a>>, usize),
+    ImportFrom(Option<PyToken<'a>>, Vec<PyImportAlias<'a>>, usize),
     FnDef(PyFnDef<'a>),
     ClassDef(PyClassDef<'a>),
     While(SPyExpr<'a>, PyBlock<'a>),
@@ -182,16 +182,16 @@ pub enum PyUnaryOp {
 #[derive(Debug, Clone)]
 pub enum PyCallItem<'a> {
     Arg(SPyExpr<'a>),
-    Kwarg(PyIdent<'a>, SPyExpr<'a>),
+    Kwarg(PyToken<'a>, SPyExpr<'a>),
     ArgSpread(SPyExpr<'a>),
     KwargSpread(SPyExpr<'a>),
 }
 
 #[derive(Debug, Clone)]
 pub enum PyArgDefItem<'a> {
-    Arg(PyIdent<'a>, Option<SPyExpr<'a>>),
-    ArgSpread(PyIdent<'a>),
-    KwargSpread(PyIdent<'a>),
+    Arg(PyToken<'a>, Option<SPyExpr<'a>>),
+    ArgSpread(PyToken<'a>),
+    KwargSpread(PyToken<'a>),
 }
 
 #[derive(Debug, Clone)]
@@ -208,7 +208,7 @@ pub enum PyDictItem<'a> {
 
 #[derive(Debug, Clone)]
 pub enum PyFstrPart<'a> {
-    Str(PyIdent<'a>),
+    Str(PyToken<'a>),
     Expr(SPyExpr<'a>, Option<SPyExpr<'a>>),
 }
 
@@ -216,12 +216,12 @@ pub enum PyFstrPart<'a> {
 pub enum PyExpr<'a> {
     Literal(PyLiteral<'a>),
     Fstr(Vec<PyFstrPart<'a>>),
-    Name(PyIdent<'a>, PyAccessCtx),
+    Name(PyToken<'a>, PyAccessCtx),
 
     Binary(PyBinaryOp, Box<SPyExpr<'a>>, Box<SPyExpr<'a>>),
     Unary(PyUnaryOp, Box<SPyExpr<'a>>),
     Call(Box<SPyExpr<'a>>, Vec<PyCallItem<'a>>),
-    Attribute(Box<SPyExpr<'a>>, PyIdent<'a>, PyAccessCtx),
+    Attribute(Box<SPyExpr<'a>>, PyToken<'a>, PyAccessCtx),
     Subscript(Box<SPyExpr<'a>>, Box<SPyExpr<'a>>, PyAccessCtx),
 
     IfExpr(Box<SPyExpr<'a>>, Box<SPyExpr<'a>>, Box<SPyExpr<'a>>),
@@ -264,8 +264,12 @@ impl<T> From<(T, Span)> for PySpanned<T> {
 
 #[derive(Debug, Clone)]
 pub enum PyLiteral<'a> {
-    Num(PyIdent<'a>),
-    Str(PyIdent<'a>),
+    Int(PyToken<'a>),
+    IntBin(PyToken<'a>),
+    IntOct(PyToken<'a>),
+    IntHex(PyToken<'a>),
+    Float(PyToken<'a>),
+    Str(PyToken<'a>),
     Bool(bool),
     None,
 }
@@ -273,21 +277,21 @@ pub enum PyLiteral<'a> {
 #[derive(Debug, Clone)]
 pub enum PyPatternSequenceItem<'a> {
     Item(SPyPattern<'a>),
-    Spread(Option<PyIdent<'a>>),
+    Spread(Option<PyToken<'a>>),
 }
 
 #[derive(Debug, Clone)]
 pub enum PyPattern<'a> {
     Value(SPyExpr<'a>),
     Singleton(PyLiteral<'a>),
-    As(Option<Box<SPyPattern<'a>>>, Option<PyIdent<'a>>),
+    As(Option<Box<SPyPattern<'a>>>, Option<PyToken<'a>>),
     Or(Vec<SPyPattern<'a>>),
     Sequence(Vec<PyPatternSequenceItem<'a>>),
-    Mapping(Vec<(SPyExpr<'a>, SPyPattern<'a>)>, Option<PyIdent<'a>>),
+    Mapping(Vec<(SPyExpr<'a>, SPyPattern<'a>)>, Option<PyToken<'a>>),
     Class(
         SPyExpr<'a>,
         Vec<SPyPattern<'a>>,
-        Vec<(PyIdent<'a>, SPyPattern<'a>)>,
+        Vec<(PyToken<'a>, SPyPattern<'a>)>,
     ),
 }