koatl 0.3.6__tar.gz → 0.3.8__tar.gz

{koatl-0.3.6 → koatl-0.3.8}/Cargo.lock

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

{koatl-0.3.6 → koatl-0.3.8}/PKG-INFO

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

{koatl-0.3.6 → koatl-0.3.8}/koatl/Cargo.toml

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

{koatl-0.3.6 → koatl-0.3.8}/koatl/python/koatl/notebook/magic.py

@@ -36,8 +36,7 @@ def _make_help_call(target, esc):
 
 
 def crepr(s):
-    assert isinstance(s, str)
-    return '"' + repr(s)[1:-1] + '"'
+    return repr(s)
 
 
 def _tr_help(content):

{koatl-0.3.6 → koatl-0.3.8}/koatl/tests/e2e/prelude/coal.tl

@@ -4,7 +4,7 @@ none = None
 assert_eq(none?(1)?(2), None)
 assert_eq(none?[1]?.a, None)
 assert_eq(none?.a, None)
-assert_eq(none?.(a), None)
+assert_eq(none?. (a), None)
 
 obj = (class:
     a = 1
@@ -13,7 +13,7 @@ obj = (class:
 assert_eq((x => x)?(1), 1)
 assert_eq([1]?[0], 1)
 assert_eq(obj?.a, 1)
-assert_eq(1?.($ + 1), 2)
+assert_eq(1?. ($ + 1), 2)
 
 assert_eq(None ?? 1, 1)
 assert_eq(int(5) ?? 1, 5)
@@ -25,4 +25,7 @@ f = () =>
 f() ?? 1
 
 # should only call once
-assert_eq(counts, 1)
+assert_eq(counts, 1)
+
+assert_eq((1).?f, None)
+assert_eq(None.?f, None)

{koatl-0.3.6 → koatl-0.3.8}/koatl-core/src/ast.rs

@@ -186,12 +186,14 @@ pub enum Expr<'a, TTree: Tree> {
     RawAttribute(TTree::Expr, SIdent<'a>),
     ScopedAttribute(TTree::Expr, TTree::Expr),
     Attribute(TTree::Expr, SIdent<'a>),
+    MaybeAttribute(TTree::Expr, SIdent<'a>),
 
     MappedCall(TTree::Expr, Vec<CallItem<'a, TTree>>),
     MappedSubscript(TTree::Expr, Vec<ListItem<TTree>>),
     MappedRawAttribute(TTree::Expr, SIdent<'a>),
     MappedScopedAttribute(TTree::Expr, TTree::Expr),
     MappedAttribute(TTree::Expr, SIdent<'a>),
+    MappedMaybeAttribute(TTree::Expr, SIdent<'a>),
 
     Try(TTree::Expr, Vec<MatchCase<TTree>>, Option<TTree::Expr>),
     Checked(TTree::Expr, Option<TTree::Pattern>),

{koatl-0.3.6 → koatl-0.3.8}/koatl-core/src/inference.rs

@@ -229,7 +229,9 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for Indirect<SExpr<'src>> {
             Expr::RawAttribute(expr, _)
             | Expr::MappedRawAttribute(expr, _)
             | Expr::Attribute(expr, _)
-            | Expr::MappedAttribute(expr, _) => {
+            | Expr::MappedAttribute(expr, _)
+            | Expr::MaybeAttribute(expr, _)
+            | Expr::MappedMaybeAttribute(expr, _) => {
                 expr.traverse(ctx);
                 Type::Any
             }

{koatl-0.3.6 → koatl-0.3.8}/koatl-core/src/lib.rs

@@ -69,12 +69,12 @@ pub fn transpile_to_py_ast<'src>(
 ) -> TlResult<PyBlock<'src>> {
     let (tl_ast, tl_errs) = parse_tl(src);
 
+    let mut errs = tl_errs;
+
     let Some(tl_ast) = tl_ast else {
-        return Err(tl_errs);
+        return Err(errs);
     };
 
-    let mut errs = tl_errs;
-
     let (resolve_state, errors, tl_ast) =
         resolve_scopes::resolve_names(src, tl_ast, options.allow_await);
 

{koatl-0.3.6 → koatl-0.3.8}/koatl-core/src/lift_cst.rs

@@ -317,6 +317,18 @@ impl<'src, 'tok> Lift<Indirect<ast::SExpr<'src>>> for cst::SExpr<'src, 'tok> {
                     ast::Expr::Attribute(expr.lift(), attr.lift_as_ident())
                 }
             }
+            cst::Expr::MaybeAttribute {
+                expr,
+                attr,
+                question,
+                ..
+            } => {
+                if question.is_some() {
+                    ast::Expr::MappedMaybeAttribute(expr.lift(), attr.lift_as_ident())
+                } else {
+                    ast::Expr::MaybeAttribute(expr.lift(), attr.lift_as_ident())
+                }
+            }
             cst::Expr::Call {
                 expr,
                 args,
@@ -468,7 +480,7 @@ impl<'src, 'tok> Lift<Indirect<ast::SStmt<'src>>> for cst::SStmt<'src, 'tok> {
                 ast::Stmt::Import(tree.lift(), export.is_some())
             }
             cst::Stmt::Error { .. } => ast::Stmt::Expr(
-                ast::Expr::Ident(ast::Ident("error".into()).spanned(self.span))
+                ast::Expr::Ident(ast::Ident("_ERROR_".into()).spanned(self.span))
                     .spanned(self.span)
                     .indirect(),
             ),

{koatl-0.3.6 → koatl-0.3.8}/koatl-core/src/resolve_scopes.rs

@@ -1410,6 +1410,20 @@ impl<'src> SExprExt<'src> for Indirect<SExpr<'src>> {
 
                 return traversed;
             }
+            Expr::MaybeAttribute(expr, attr) => {
+                Expr::MaybeAttribute(expr.traverse(state), attr.clone())
+            }
+            Expr::MappedMaybeAttribute(expr, attr) => {
+                let traversed = Expr::MappedMaybeAttribute(expr.traverse(state), attr)
+                    .spanned(span)
+                    .indirect();
+
+                state
+                    .mapped_fninfo
+                    .insert(traversed.as_ref().into(), FnInfo::new());
+
+                return traversed;
+            }
             Expr::RawAttribute(expr, attr) => Expr::RawAttribute(expr.traverse(state), attr),
             Expr::MappedRawAttribute(expr, spanned) => {
                 let traversed = Expr::MappedRawAttribute(expr.traverse(state), spanned)

{koatl-0.3.6 → koatl-0.3.8}/koatl-core/src/transform.rs

@@ -1,4 +1,3 @@
-use core::fmt;
 use std::{
     borrow::Cow,
     collections::{HashMap, HashSet},
@@ -1315,11 +1314,13 @@ fn transform_postfix_expr<'src, 'ast>(
         Expr::Call(obj, _) => (false, obj),
         Expr::ScopedAttribute(obj, _) => (false, obj),
         Expr::Attribute(obj, _) => (false, obj),
+        Expr::MaybeAttribute(obj, _) => (false, obj),
         Expr::MappedRawAttribute(obj, _) => (true, obj),
         Expr::MappedSubscript(obj, _) => (true, obj),
         Expr::MappedCall(obj, _) => (true, obj),
         Expr::MappedScopedAttribute(obj, _) => (true, obj),
         Expr::MappedAttribute(obj, _) => (true, obj),
+        Expr::MappedMaybeAttribute(obj, _) => (true, obj),
         _ => {
             return Err(simple_err(
                 "Internal error: Postfix expressions can only be attributes, subscripts, calls, or extensions",
@@ -1365,6 +1366,29 @@ fn transform_postfix_expr<'src, 'ast>(
                     a.attribute(lhs, rhs.value.escape(), access_ctx)
                 }
             }
+            Expr::MaybeAttribute(_, rhs) | Expr::MappedMaybeAttribute(_, rhs) => {
+                let temp_var = ctx.create_aux_var("attr", expr.span.start);
+
+                inner_pre.push(a.try_(
+                    PyBlock(vec![a.assign(
+                        a.ident(temp_var.clone(), PyAccessCtx::Store),
+                        a.call(
+                            a.tl_builtin("vget"),
+                            vec![a.call_arg(lhs), a.call_arg(a.str(rhs.value.escape()))],
+                        ),
+                    )]),
+                    vec![PyExceptHandler {
+                        typ: None,
+                        name: None,
+                        body: PyBlock(vec![
+                            a.assign(a.ident(temp_var.clone(), PyAccessCtx::Store), a.none()),
+                        ]),
+                    }],
+                    None,
+                ));
+
+                a.load_ident(temp_var)
+            }
             _ => {
                 panic!()
             }
@@ -1906,7 +1930,11 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for SExpr<'src> {
             | Expr::ScopedAttribute(..)
             | Expr::MappedScopedAttribute(..)
             | Expr::Attribute(..)
-            | Expr::MappedAttribute(..) => pre.bind(transform_postfix_expr(ctx, self, access_ctx)?),
+            | Expr::MappedAttribute(..)
+            | Expr::MaybeAttribute(..)
+            | Expr::MappedMaybeAttribute(..) => {
+                pre.bind(transform_postfix_expr(ctx, self, access_ctx)?)
+            }
             Expr::With(pattern, value, body) => {
                 let temp_var = ctx.create_aux_var("with", span.start);
                 let value = pre.bind(value.transform(ctx)?);

{koatl-0.3.6 → koatl-0.3.8}/koatl-parser/src/cst.rs

@@ -465,6 +465,13 @@ pub enum Expr<TTree: Tree> {
         rhs: TTree::Expr,
         rparen: TTree::Token,
     },
+    MaybeAttribute {
+        expr: TTree::Expr,
+        question: Option<TTree::Token>,
+        dot: TTree::Token,
+        question2: TTree::Token,
+        attr: TTree::Token,
+    },
     Attribute {
         expr: TTree::Expr,
         question: Option<TTree::Token>,

{koatl-0.3.6 → koatl-0.3.8}/koatl-parser/src/lexer.rs

@@ -1542,6 +1542,11 @@ impl<'src> TokenizeCtx<'src> {
             }
         };
 
+        if delim_stack.len() > 0 {
+            let (_unmatched_char, span) = delim_stack.pop().unwrap();
+            return Err(LexError::custom(span, "unmatched delimiter"));
+        }
+
         let len = tokens.len();
         for i in (0..len).rev() {
             // avoid putting trivia on an eol token

{koatl-0.3.6 → koatl-0.3.8}/koatl-parser/src/parser.rs

@@ -1276,6 +1276,11 @@ impl<'src: 'tok, 'tok> ParseCtx<'src, 'tok> {
                 rhs: SExpr<'src, 'tok>,
                 rparen: &'tok SToken<'src>,
             },
+            MaybeAttribute {
+                question: &'tok SToken<'src>,
+                dot: &'tok SToken<'src>,
+                attr: &'tok SToken<'src>,
+            },
             Attribute {
                 dot: &'tok SToken<'src>,
                 attr: &'tok SToken<'src>,
@@ -1341,6 +1346,15 @@ impl<'src: 'tok, 'tok> ParseCtx<'src, 'tok> {
                             ctx.listing("(", ")", Token::Symbol(","), |ctx| ctx.call_item())?;
                         Ok(Postfix::MethodCall { dot, method, args })
                     },
+                    |ctx| {
+                        let question = ctx.symbol("?")?;
+                        let attr = ctx.any_ident()?;
+                        Ok(Postfix::MaybeAttribute {
+                            question,
+                            dot,
+                            attr,
+                        })
+                    },
                     |ctx| {
                         let attr = ctx.any_ident()?;
                         Ok(Postfix::Attribute { dot, attr })
@@ -1411,6 +1425,17 @@ impl<'src: 'tok, 'tok> ParseCtx<'src, 'tok> {
                         dot,
                         attr,
                     },
+                    Postfix::MaybeAttribute {
+                        question: question2,
+                        dot,
+                        attr,
+                    } => Expr::MaybeAttribute {
+                        expr: expr.boxed(),
+                        question,
+                        dot,
+                        question2,
+                        attr,
+                    },
                     Postfix::Decorator { op, decorator } => {
                         if question.is_some() {
                             return Err(self.set_error(
@@ -2455,7 +2480,7 @@ impl<'src: 'tok, 'tok> ParseCtx<'src, 'tok> {
                         }
                         None => {
                             stmts.push(err_stmt);
-                            break 'outer;
+                            return Err(());
                         }
                     }
                     self.next();
@@ -2509,7 +2534,15 @@ pub fn parse_tokens<'src: 'tok, 'tok>(
             .map(|err| {
                 (
                     true_span(err.index, err.index + 1, ctx.input),
-                    format!("{:?}. Found: {:?}", err.message, tokens.0[err.index].token),
+                    format!(
+                        "{:?}. Found: {}",
+                        err.message,
+                        tokens
+                            .0
+                            .get(err.index)
+                            .map(|x| format!("{:?}", x.token))
+                            .unwrap_or("Eof".into())
+                    ),
                 )
             })
             .collect(),

{koatl-0.3.6 → koatl-0.3.8}/koatl-parser/src/simple_fmt.rs

@@ -190,6 +190,20 @@ impl<'src, 'tok> SimpleFmt for SExprInner<'src, 'tok> {
                     attr.simple_fmt()
                 )
             }
+            Expr::MaybeAttribute {
+                expr,
+                question,
+                attr,
+                ..
+            } => {
+                let question_str = if question.is_some() { "?" } else { "" };
+                format!(
+                    "{}{}.?{}",
+                    expr.simple_fmt(),
+                    question_str,
+                    attr.simple_fmt()
+                )
+            }
             Expr::Slice {
                 start,
                 dots: _,

{koatl-0.3.6 → koatl-0.3.8}/python/koatl/notebook/magic.py

@@ -36,8 +36,7 @@ def _make_help_call(target, esc):
 
 
 def crepr(s):
-    assert isinstance(s, str)
-    return '"' + repr(s)[1:-1] + '"'
+    return repr(s)
 
 
 def _tr_help(content):