koatl 0.3.11__tar.gz → 0.3.12__tar.gz

{koatl-0.3.11 → koatl-0.3.12}/Cargo.lock

@@ -190,7 +190,7 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "koatl"
-version = "0.3.11"
+version = "0.3.12"
 dependencies = [
  "ariadne",
  "koatl-core",

{koatl-0.3.11 → koatl-0.3.12}/PKG-INFO

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

{koatl-0.3.11 → koatl-0.3.12}/koatl/Cargo.toml

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

{koatl-0.3.11 → koatl-0.3.12}/koatl-core/src/ast.rs

@@ -138,8 +138,8 @@ pub enum ArgDefItem<'a, TTree: Tree> {
     Arg(TTree::Pattern, Option<TTree::Expr>),
     ArgSpread(SIdent<'a>),
     KwargSpread(SIdent<'a>),
-    PosOnlyMarker,
-    KwOnlyMarker,
+    PosOnlyMarker(Spanned<()>),
+    KwOnlyMarker(Spanned<()>),
 }
 
 #[derive(Debug, Clone)]

{koatl-0.3.11 → koatl-0.3.12}/koatl-core/src/lift_cst.rs

@@ -555,8 +555,12 @@ impl<'src, 'tok> Lift<ast::ArgDefItem<'src, ast::STree<'src>>>
             cst::ArgDefItem::KwargSpread { name, .. } => {
                 ast::ArgDefItem::KwargSpread(name.lift_as_ident())
             }
-            cst::ArgDefItem::PosOnlyMarker { .. } => ast::ArgDefItem::PosOnlyMarker,
-            cst::ArgDefItem::KwOnlyMarker { .. } => ast::ArgDefItem::KwOnlyMarker,
+            cst::ArgDefItem::PosOnlyMarker { slash } => {
+                ast::ArgDefItem::PosOnlyMarker(().spanned(slash.span))
+            }
+            cst::ArgDefItem::KwOnlyMarker { star } => {
+                ast::ArgDefItem::KwOnlyMarker(().spanned(star.span))
+            }
         }
     }
 }

{koatl-0.3.11 → koatl-0.3.12}/koatl-core/src/resolve_scopes.rs

@@ -1290,8 +1290,8 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
 
                             ArgDefItem::KwargSpread(arg)
                         }
-                        ArgDefItem::PosOnlyMarker => ArgDefItem::PosOnlyMarker,
-                        ArgDefItem::KwOnlyMarker => ArgDefItem::KwOnlyMarker,
+                        ArgDefItem::PosOnlyMarker(spanned) => ArgDefItem::PosOnlyMarker(spanned),
+                        ArgDefItem::KwOnlyMarker(spanned) => ArgDefItem::KwOnlyMarker(spanned),
                     })
                     .collect::<Vec<_>>();
 

{koatl-0.3.11 → koatl-0.3.12}/koatl-core/src/transform.rs

@@ -981,53 +981,37 @@ fn make_arglist<'src, 'ast>(
                         ));
                     }
                 }
-                ArgDefItem::PosOnlyMarker => {
-                    // Get a span - we'll use the first arg's span as a fallback
-                    let span = args
-                        .first()
-                        .and_then(|a| match a {
-                            ArgDefItem::Arg(p, _) => Some(p.span),
-                            ArgDefItem::ArgSpread(n) | ArgDefItem::KwargSpread(n) => Some(n.span),
-                            _ => None,
-                        })
-                        .unwrap_or(Span { start: 0, end: 0 });
-
+                ArgDefItem::PosOnlyMarker(spanned) => {
                     if seen_posonly_marker.is_some() {
                         return Err(simple_err(
                             "Only one position-only marker (/) is allowed",
-                            span,
+                            spanned.span,
                         ));
                     }
                     if seen_kwonly_marker.is_some() || seen_vararg.is_some() {
                         return Err(simple_err(
                             "Position-only marker (/) must come before * or *args",
-                            span,
+                            spanned.span,
                         ));
                     }
-                    seen_posonly_marker = Some(span);
+                    seen_posonly_marker = Some(spanned.span);
                     // Reset for regular args section
                     seen_default = false;
                 }
-                ArgDefItem::KwOnlyMarker => {
-                    let span = args
-                        .first()
-                        .and_then(|a| match a {
-                            ArgDefItem::Arg(p, _) => Some(p.span),
-                            ArgDefItem::ArgSpread(n) | ArgDefItem::KwargSpread(n) => Some(n.span),
-                            _ => None,
-                        })
-                        .unwrap_or(Span { start: 0, end: 0 });
-
+                ArgDefItem::KwOnlyMarker(spanned) => {
                     if seen_kwonly_marker.is_some() {
                         return Err(simple_err(
                             "Only one keyword-only marker (*) is allowed",
-                            span,
+                            spanned.span,
                         ));
                     }
                     if seen_vararg.is_some() {
-                        return Err(simple_err("Cannot have both *args and bare * marker", span));
+                        return Err(simple_err(
+                            "Cannot have both *args and bare * marker",
+                            spanned.span,
+                        ));
                     }
-                    seen_kwonly_marker = Some(span);
+                    seen_kwonly_marker = Some(spanned.span);
                     after_kwonly_marker = true;
                     seen_default = false;
                 }
@@ -1088,11 +1072,11 @@ fn make_arglist<'src, 'ast>(
                     _ => kwonlyargs.push((cursor, default)),
                 }
             }
-            ArgDefItem::PosOnlyMarker => {
+            ArgDefItem::PosOnlyMarker(..) => {
                 // Transition from position-only to regular args
                 state = 1;
             }
-            ArgDefItem::KwOnlyMarker => {
+            ArgDefItem::KwOnlyMarker(..) => {
                 // Bare * marker - transition to keyword-only without vararg
                 state = 2;
             }