koatl 0.3.5__tar.gz → 0.3.6__tar.gz

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

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

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

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

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

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

{koatl-0.3.5 → koatl-0.3.6/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.6}/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.6}/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
@@ -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.6}/koatl-core/src/transform.rs

@@ -1,3 +1,4 @@
+use core::fmt;
 use std::{
     borrow::Cow,
     collections::{HashMap, HashSet},
@@ -70,6 +71,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 +102,7 @@ impl<'src, 'ast> TlCtx<'src, 'ast> {
             declarations: &resolve_state.declarations,
 
             types: &inference.types,
+            target_version: (3, 12),
         })
     }
 
@@ -208,7 +212,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 +2246,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 +2381,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 +2398,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 → koatl-0.3.6}/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")