koatl 0.3.5__tar.gz → 0.3.7__tar.gz

{koatl-0.3.5 → koatl-0.3.7}/Cargo.lock

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

{koatl-0.3.5 → koatl-0.3.7}/PKG-INFO

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

{koatl-0.3.5 → koatl-0.3.7}/koatl/Cargo.toml

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

{koatl-0.3.5 → koatl-0.3.7/koatl}/python/koatl/runtime/meta_finder.py

@@ -52,13 +52,18 @@ class TlLoader(Loader):
             self.filepath,
         )
 
+        ver = (sys.version_info.major, sys.version_info.minor)
+
         if module.__name__.startswith("koatl"):
             transpiled_code = transpile(
-                source_code, mode="no_prelude", filename=self.filepath
+                source_code,
+                mode="no_prelude",
+                filename=self.filepath,
+                target_version=ver,
             )
         else:
             transpiled_code = transpile(
-                source_code, mode="module", filename=self.filepath
+                source_code, mode="module", filename=self.filepath, target_version=ver
             )
 
         code = compile(transpiled_code, self.filepath, "exec")

{koatl-0.3.5 → koatl-0.3.7}/koatl/src/lib.rs

@@ -25,9 +25,17 @@ fn get_option(mode: &str) -> PyResult<TranspileOptions> {
     })
 }
 
-#[pyfunction(signature=(src, mode="script", filename="<string>"))]
-fn transpile(src: &str, mode: &str, filename: &str) -> PyResult<PyObject> {
-    let options = get_option(mode)?;
+#[pyfunction(signature=(src, mode="script", filename="<string>", target_version=None))]
+fn transpile(
+    src: &str,
+    mode: &str,
+    filename: &str,
+    target_version: Option<(usize, usize)>,
+) -> PyResult<PyObject> {
+    let mut options = get_option(mode)?;
+    if let Some(ver) = target_version {
+        options.target_version = ver;
+    }
 
     let py_ast = transpile_to_py_ast(src, filename, options).map_err(|e| {
         PyErr::new::<pyo3::exceptions::PySyntaxError, _>(format_errs(&e, filename, src))
@@ -39,9 +47,17 @@ fn transpile(src: &str, mode: &str, filename: &str) -> PyResult<PyObject> {
     Ok(py_ast_obj)
 }
 
-#[pyfunction(signature=(src, mode="script", filename="<string>"))]
-fn transpile_raw(src: &str, mode: &str, filename: &str) -> PyResult<PyObject> {
-    let options = get_option(mode)?;
+#[pyfunction(signature=(src, mode="script", filename="<string>", target_version=None))]
+fn transpile_raw(
+    src: &str,
+    mode: &str,
+    filename: &str,
+    target_version: Option<(usize, usize)>,
+) -> PyResult<PyObject> {
+    let mut options = get_option(mode)?;
+    if let Some(ver) = target_version {
+        options.target_version = ver;
+    }
 
     let ctx = transpile_to_source(src, filename, options).map_err(|e| {
         PyErr::new::<pyo3::exceptions::PySyntaxError, _>(format_errs(&e, filename, src))

{koatl-0.3.5 → koatl-0.3.7}/koatl-core/src/lib.rs

@@ -20,6 +20,7 @@ use crate::util::{TlErr, TlErrKind, TlErrs, TlResult};
 use ariadne::{Color, Label, Report, ReportKind, sources};
 
 pub struct TranspileOptions {
+    pub target_version: (usize, usize),
     pub inject_prelude: bool,
     pub inject_runtime: bool,
     pub set_exports: bool,
@@ -28,16 +29,23 @@ pub struct TranspileOptions {
 }
 
 impl TranspileOptions {
-    pub fn script() -> Self {
+    pub fn module() -> Self {
         TranspileOptions {
             inject_prelude: true,
             inject_runtime: true,
-            interactive: false,
-            set_exports: false,
+            set_exports: true,
             allow_await: false,
+            interactive: false,
+            target_version: (3, 12),
         }
     }
 
+    pub fn script() -> Self {
+        let mut opt = TranspileOptions::module();
+        opt.set_exports = false;
+        opt
+    }
+
     pub fn interactive() -> Self {
         let mut opt = TranspileOptions::script();
         opt.inject_prelude = false;
@@ -47,16 +55,6 @@ impl TranspileOptions {
         opt
     }
 
-    pub fn module() -> Self {
-        TranspileOptions {
-            allow_await: false,
-            inject_prelude: true,
-            inject_runtime: true,
-            set_exports: true,
-            interactive: false,
-        }
-    }
-
     pub fn no_prelude() -> Self {
         let mut opt = TranspileOptions::module();
         opt.inject_prelude = false; // don't inject the prelude when loading prelude
@@ -71,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);
 
@@ -96,7 +94,10 @@ pub fn transpile_to_py_ast<'src>(
         &tl_ast,
         &resolve_state,
         &inference,
-        options.interactive,
+        transform::TransformOptions {
+            interactive: options.interactive,
+            target_version: options.target_version,
+        },
     ) {
         Ok(output) => Some(output),
         Err(e) => {

{koatl-0.3.5 → koatl-0.3.7}/koatl-core/src/lift_cst.rs

@@ -468,7 +468,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.5 → koatl-0.3.7}/koatl-core/src/transform.rs

@@ -70,6 +70,8 @@ struct TlCtx<'src, 'ast> {
     declarations: &'ast SlotMap<DeclarationKey, Declaration<'src>>,
 
     types: &'ast HashMap<RefHash, Type>,
+
+    target_version: (usize, usize),
 }
 
 impl<'src, 'ast> TlCtx<'src, 'ast> {
@@ -99,6 +101,7 @@ impl<'src, 'ast> TlCtx<'src, 'ast> {
             declarations: &resolve_state.declarations,
 
             types: &inference.types,
+            target_version: (3, 12),
         })
     }
 
@@ -208,7 +211,7 @@ fn deduplicate<'src, 'ast>(
     expr: SPyExpr<'src>,
     span: Span,
 ) -> TlResult<SPyExprWithPre<'src>> {
-    let var_name = ctx.create_aux_var("lhs", span.start);
+    let var_name = ctx.create_aux_var("exp", span.start);
     let a = PyAstBuilder::new(span);
     let mut pre = PyBlock::new();
 
@@ -2242,7 +2245,15 @@ impl<'src, 'ast> SExprExt<'src, 'ast> for SExpr<'src> {
                 nodes.push(PyFstrPart::Str(begin.value.clone().into()));
 
                 for (fmt_expr, str_part) in parts {
-                    let expr = pre.bind(fmt_expr.expr.transform(ctx)?);
+                    // Nested strings are not allowed in f-strings pre 3.12,
+                    // so lift the expression part out
+                    let expr = if ctx.target_version >= (3, 12) {
+                        pre.bind(fmt_expr.expr.transform(ctx)?)
+                    } else {
+                        let e = pre.bind(fmt_expr.expr.transform(ctx)?);
+                        pre.bind(deduplicate(ctx, e, fmt_expr.expr.span)?)
+                    };
+
                     let fmt = fmt_expr
                         .fmt
                         .as_ref()
@@ -2369,6 +2380,11 @@ fn py_fn_bindings<'src, 'ast>(
     Ok((py_body, nonlocals, globals))
 }
 
+pub struct TransformOptions {
+    pub interactive: bool,
+    pub target_version: (usize, usize),
+}
+
 pub struct TransformOutput<'src> {
     pub py_block: PyBlock<'src>,
     pub exports: Vec<PyToken<'src>>,
@@ -2381,11 +2397,12 @@ pub fn transform_ast<'src, 'ast>(
     block: &'ast SExpr<'src>,
     resolve_state: &'ast ResolveState<'src>,
     inference: &'ast InferenceCtx<'src, 'ast>,
-    interactive: bool,
+    options: TransformOptions,
 ) -> TlResult<TransformOutput<'src>> {
     let mut ctx = TlCtx::new(source, filename, resolve_state, inference)?;
+    ctx.target_version = options.target_version;
 
-    let py_block = if interactive {
+    let py_block = if options.interactive {
         let mut py_value = block.transform(&mut ctx)?;
         let span = py_value.value.tl_span;
         py_value

{koatl-0.3.5 → koatl-0.3.7}/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.5 → koatl-0.3.7}/koatl-parser/src/parser.rs

@@ -2455,7 +2455,7 @@ impl<'src: 'tok, 'tok> ParseCtx<'src, 'tok> {
                         }
                         None => {
                             stmts.push(err_stmt);
-                            break 'outer;
+                            return Err(());
                         }
                     }
                     self.next();
@@ -2509,7 +2509,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.5/koatl → koatl-0.3.7}/python/koatl/runtime/meta_finder.py

@@ -52,13 +52,18 @@ class TlLoader(Loader):
             self.filepath,
         )
 
+        ver = (sys.version_info.major, sys.version_info.minor)
+
         if module.__name__.startswith("koatl"):
             transpiled_code = transpile(
-                source_code, mode="no_prelude", filename=self.filepath
+                source_code,
+                mode="no_prelude",
+                filename=self.filepath,
+                target_version=ver,
             )
         else:
             transpiled_code = transpile(
-                source_code, mode="module", filename=self.filepath
+                source_code, mode="module", filename=self.filepath, target_version=ver
             )
 
         code = compile(transpiled_code, self.filepath, "exec")