rapydscript-ng 0.8.2 → 0.8.4

package/src/utils.pyj

@@ -2,7 +2,8 @@
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
 from __python__ import hash_literals
 
-has_prop = Object.prototype.hasOwnProperty.call.bind(Object.prototype.hasOwnProperty)
+has_prop = Object.prototype.hasOwnProperty.call.bind(
+    Object.prototype.hasOwnProperty)
 
 
 def array_to_hash(a):
@@ -41,7 +42,11 @@ def repeat_string(str_, i):
 
 class DefaultsError(ValueError):
     def __init__(self, name, defs):
-        ValueError.__init__(self, name + ' is not a supported option. Supported options are: ' + str(Object.keys(defs)))
+        ValueError.__init__(
+            self,
+            name + ' is not a supported option. Supported options are: '
+            + str(Object.keys(defs))
+        )
 
 
 def defaults(args, defs, croak):
@@ -80,12 +85,18 @@ MAP = def ():
             if isinstance(val, AtTop):
                 val = val.v
                 if isinstance(val, Splice):
-                    top.push.apply(top, (val.v.slice().reverse() if backwards else val.v))
+                    top.push.apply(
+                        top,
+                        (val.v.slice().reverse() if backwards else val.v)
+                    )
                 else:
                     top.push(val)
             elif val is not skip:
                 if isinstance(val, Splice):
-                    ret.push.apply(ret, (val.v.slice().reverse() if backwards else val.v))
+                    ret.push.apply(
+                        ret,
+                        (val.v.slice().reverse() if backwards else val.v)
+                    )
                 else:
                     ret.push(val)
             return is_last
@@ -205,5 +216,8 @@ def make_predicate(words):
 def cache_file_name(src, cache_dir):
     if cache_dir:
         src = str.replace(src, '\\', '/')
-        return cache_dir + '/' + str.lstrip(str.replace(src, '/', '-') + '.bin', '-')
+        return cache_dir + '/' + str.lstrip(
+            str.replace(src, '/', '-') + '.bin',
+            '-'
+        )
     return src + '-cached'

package/test/functions.pyj

@@ -22,6 +22,14 @@ mul = None
 assrt.equal(add(1,2), 3)
 assrt.equal(sub(1,2), -1)
 assrt.equal(mul(2,2), 4)
+
+# newline as implicit comma separator in function calls
+assrt.equal(add(1
+2), 3)
+assrt.equal(sub(1
+2), -1)
+assrt.equal(add(list().length
+list().length), 0)
 # for some reason input to throws must be of type block, hence the 'def' wrapper
 assrt.throws(
     def():

package/test/generic.pyj

@@ -48,6 +48,15 @@ assrt.deepEqual((1,
 assrt.deepEqual((1,
                  2), [1, 2])
 
+# Tuples with newlines as implicit separators (no comma)
+assrt.deepEqual((1
+2), [1, 2])
+assrt.deepEqual((list()
+list()), [[], []])
+assrt.deepEqual((1
+2
+3), [1, 2, 3])
+
 # Conditional operators
 assrt.equal(1 if True else 2, 1)
 assrt.equal(1

package/test/lsp.pyj

@@ -50,6 +50,22 @@ async def test_diagnostics():
     assrt.ok(c['import-unresolved'], 'expected import-unresolved for nonexistent_module')
     fs.rmSync(tmp, {'recursive': True})
 
+async def test_globals_directive_suppresses_undef():
+    tmp = write_workspace()
+    ctx = make_ctx(tmp)
+    uri = uri_of(path.join(tmp, 'globals_test.pyj'))
+    # ext_func is declared via # globals: so it must not produce an undef diagnostic.
+    text = '# globals: ext_func\n\nresult = ext_func(42)\n'
+    diags = await lsp.compute_diagnostics(ctx, uri, text)
+    c = codes(diags)
+    assrt.ok(not c['undef'], 'ext_func declared in # globals: must not be flagged as undef')
+    # A name NOT in # globals: must still be flagged.
+    text2 = '# globals: ext_func\n\nresult = ext_func(42)\nbad = undeclared_thing()\n'
+    diags2 = await lsp.compute_diagnostics(ctx, uri, text2)
+    c2 = codes(diags2)
+    assrt.ok(c2['undef'], 'undeclared_thing not in # globals: must still be flagged as undef')
+    fs.rmSync(tmp, {'recursive': True})
+
 async def test_hover_and_definition():
     tmp = write_workspace()
     ctx = make_ctx(tmp)

package/test/str.pyj

@@ -65,6 +65,16 @@ def test_interpolation():
     ae('a' f'{a}' 'b', 'a1b')
     ae('a' f'{a}' f'{a}', 'a11')
     ae(rf'raw{a}' f' and {a}', 'raw1 and 1')
+    # Test f-string + string concatenation across newlines inside brackets
+    ae(f'{a}'
+       "b", '1b')
+    ae(f'{a}'
+       f'{a}', '11')
+    ae('a'
+       f'{a}', 'a1')
+    ae(f'{a}'
+       "b"
+       f'{a}', '1b1')
 
 somevar = 33
 test('somevar=33', '{somevar=}', somevar=somevar)

package/tools/cli.mjs

@@ -318,11 +318,12 @@ command prompt.`);
 opt("no_js", '', 'bool', false, `Do not display the compiled JavaScript before executing
 it.`);
 
-create_group('lint', "[input1.pyj input2.pyj ...]", `Run the RapydScript linter. This will find various
+create_group('lint', "[input1.pyj dir1 ...]", `Run the RapydScript linter. This will find various
 possible problems in the .pyj files you specify and
 write messages about them to stdout. Use - to read from STDIN.
-The main check it performs is for unused/undefined
-symbols, like pyflakes does for python.`,
+You can specify directories to recursively lint all .pyj
+files within them. The main check it performs is for
+unused/undefined symbols, like pyflakes does for python.`,
 `In addition to the command line options listed below,
 you can also control the linter in a couple of other ways.
 

package/tools/compile.mjs

@@ -111,6 +111,12 @@ export default async function(start_time, argv, base_path, src_path, lib_path) {
         });
     }
 
+    function write_to_stream(stream, data) {
+        return new Promise((resolve, reject) => {
+            stream.write(data + '\n', 'utf8', err => err ? reject(err) : resolve());
+        });
+    }
+
     async function write_output(js_output, output_stream) {
         if (argv.source_map && output_stream) {
             var segments = output_stream.get_source_map_segments();
@@ -123,11 +129,11 @@ export default async function(start_time, argv, base_path, src_path, lib_path) {
         }
         if (argv.output) {
             // Node's filesystem module cannot write directly to /dev/stdout
-            if (argv.output == '/dev/stdout') console.log(js_output);
-            else if (argv.output == '/dev/stderr') console.error(js_output);
+            if (argv.output == '/dev/stdout') await write_to_stream(process.stdout, js_output);
+            else if (argv.output == '/dev/stderr') await write_to_stream(process.stderr, js_output);
             else await fs.promises.writeFile(argv.output, js_output, "utf8");
         } else if (!argv.execute){
-            console.log(js_output);
+            await write_to_stream(process.stdout, js_output);
         }
         if (argv.execute) {
             vm.runInNewContext(js_output, {'console':console, 'require':require}, {'filename':files[0]});

package/tools/compiler.mjs

@@ -13,7 +13,6 @@ import path from 'path';
 import fs from 'fs';
 import crypto from 'crypto';
 import vm from 'vm';
-import * as terser from 'terser';
 import { fileURLToPath } from 'url';
 import { createRequire } from 'module';
 import { generate_source_map } from './sourcemap.mjs';
@@ -39,11 +38,6 @@ async function path_exists(p) {
     }
 }
 
-function uglify(code) {
-    var ans = terser.minify_sync(code);
-    if (ans.error) throw ans.error;
-    return ans.code;
-}
 
 
 async function find_compiler_dir() {

package/tools/fmt.mjs

@@ -848,13 +848,51 @@ function normalize_opts(options) {
 // check-only reporting
 // ---------------------------------------------------------------------------
 
+// Returns a Set of 0-based line indices that fall inside vr/v verbatim
+// triple-quoted blocks.  The formatter cannot reflow that content (it is
+// raw JS/text), so line-length violations inside those blocks are skipped.
+function verbatim_line_set(lines) {
+    var skip = new Set();
+    var in_block = false;
+    var close_q = null;
+    for (var i = 0; i < lines.length; i++) {
+        var line = lines[i];
+        if (!in_block) {
+            // Detect the opening of a verbatim triple-quoted block.
+            // Patterns: vr''', vr""", v''', v"""  (with any combination of
+            // v/r/u/f prefix letters, case-insensitive).
+            var m = /\b[vrufVRUF]*(?:'{3}|"{3})/.exec(line);
+            if (m) {
+                var q = m[0].slice(-3);   // ''' or """
+                var after = line.slice(m.index + m[0].length);
+                if (after.indexOf(q) < 0) {
+                    // Block does not close on the same line.
+                    in_block = true;
+                    close_q = q;
+                    skip.add(i);  // opening line itself may be long
+                }
+                // If it closes on the same line we leave skip alone —
+                // the single-line v'...' case is handled per-line below.
+            }
+        } else {
+            skip.add(i);
+            if (line.indexOf(close_q) >= 0) {
+                in_block = false;
+                close_q = null;
+            }
+        }
+    }
+    return skip;
+}
+
 export function check_report(file, src, formatted, options) {
     var opts = normalize_opts(options);
     var errs = [];
     if (formatted !== src.replace(/\r\n?/g, '\n')) errs.push(file + ': would be reformatted');
     var lines = formatted.split('\n');
+    var skip = verbatim_line_set(lines);
     for (var i = 0; i < lines.length; i++) {
-        if (lines[i].length > opts.line_length) {
+        if (!skip.has(i) && lines[i].length > opts.line_length) {
             errs.push(file + ':' + (i + 1) + ': line exceeds ' + opts.line_length + ' characters (' + lines[i].length + ')');
         }
     }
@@ -970,8 +1008,9 @@ export async function cli(argv, base_path, src_path, lib_path) {
                 console.log('reformatted ' + f);
             }
             var flines = formatted.split('\n');
+            var fskip = verbatim_line_set(flines);
             for (var li = 0; li < flines.length; li++) {
-                if (flines[li].length > opts.line_length) {
+                if (!fskip.has(li) && flines[li].length > opts.line_length) {
                     console.error(f + ':' + (li + 1) + ': line exceeds ' + opts.line_length + ' characters (' + flines[li].length + ')');
                     had_errors = true;
                 }

package/tools/lint-worker.mjs

@@ -0,0 +1,107 @@
+/* vim:fileencoding=utf-8
+ *
+ * Copyright (C) 2015 Kovid Goyal <kovid at kovidgoyal.net>
+ *
+ * Distributed under terms of the BSD license
+ *
+ * Worker thread for parallel linting. Each worker owns its own compiler
+ * instance so parsing can run on multiple CPU cores simultaneously.
+ */
+
+import { parentPort, workerData } from 'worker_threads';
+import { create_compiler } from './compiler.mjs';
+import { read_config } from './ini.mjs';
+import * as utils from './utils.mjs';
+import fs from 'fs';
+import path from 'path';
+
+const merge = utils.merge;
+const has_prop = Object.prototype.hasOwnProperty.call.bind(Object.prototype.hasOwnProperty);
+
+// Restore embedded assets forwarded by the main thread (needed in compiled binaries
+// where workers don't inherit the main thread's globalThis).
+if (workerData && workerData.embedded) {
+    globalThis.__rapydscript_embedded__ = workerData.embedded;
+}
+
+// Initialize the compiler first — lint.mjs reads globalThis.create_rapydscript_compiler
+// at module evaluation time, so the global must be set before the dynamic import.
+const compiler = await create_compiler();
+globalThis.create_rapydscript_compiler = () => compiler;
+
+// Safe to import now.
+const { lint_code } = await import('./lint.mjs');
+
+// Per-worker ini cache keyed by directory. Stores promises to deduplicate
+// concurrent lookups for the same directory.
+const ini_cache = {};
+
+function get_ini(dir) {
+    if (!has_prop(ini_cache, dir)) {
+        ini_cache[dir] = read_config(dir).then(r => r.rapydscript || {});
+    }
+    return ini_cache[dir];
+}
+
+// Signal to the main thread that this worker is ready to receive jobs.
+parentPort.postMessage({ type: 'ready' });
+
+parentPort.on('message', async (msg) => {
+    if (msg.type !== 'lint') return;
+    const { id, filename, base_builtins, base_noqa } = msg;
+
+    try {
+        const code = await fs.promises.readFile(filename, 'utf-8');
+
+        const final_builtins = merge(base_builtins);
+        const final_noqa = merge(base_noqa);
+
+        const rl = await get_ini(path.dirname(filename));
+        const g = {};
+        (rl.globals || rl.builtins || '').split(',').forEach(function(x) { g[x.trim()] = true; });
+        Object.assign(final_builtins, g);
+
+        const ng = {};
+        (rl.noqa || '').split(',').forEach(function(x) { ng[x.trim()] = true; });
+        Object.assign(final_noqa, ng);
+
+        code.split('\n', 20).forEach(function(line) {
+            var lq = line.replace(/\s+/g, '');
+            if (lq.startsWith('#globals:')) {
+                (lq.split(':', 2)[1] || '').split(',').forEach(function(item) { final_builtins[item] = true; });
+            } else if (lq.startsWith('#noqa:')) {
+                (lq.split(':', 2)[1] || '').split(',').forEach(function(item) { final_noqa[item] = true; });
+            }
+        });
+
+        // Suppress per-file output; the main thread reports in file order.
+        const messages = await lint_code(code, {
+            filename,
+            builtins: final_builtins,
+            noqa: final_noqa,
+            errorformat: false,
+            report: function() {},
+        });
+
+        // Strip code_lines — it is never used by the CLI report functions and
+        // transferring it across threads would be wasteful.
+        const clean = messages.map(function(m) {
+            return {
+                filename: m.filename,
+                start_line: m.start_line,
+                start_col: m.start_col,
+                end_line: m.end_line,
+                end_col: m.end_col,
+                ident: m.ident,
+                message: m.message,
+                level: m.level,
+                name: m.name,
+                other_line: m.other_line,
+            };
+        });
+
+        parentPort.postMessage({ type: 'result', id, messages: clean });
+    } catch (e) {
+        parentPort.postMessage({ type: 'error', id, error: e.message || String(e) });
+    }
+});

package/tools/lint.mjs

@@ -663,11 +663,12 @@ function cli_vim_report(r) {
 
 var ini_cache = {};
 
-async function get_ini(toplevel_dir) {
-    if (has_prop(ini_cache, toplevel_dir)) return ini_cache[toplevel_dir];
-    var rl = (await read_config(toplevel_dir)).rapydscript || {};
-    ini_cache[toplevel_dir] = rl;
-    return rl;
+function get_ini(toplevel_dir) {
+    if (!has_prop(ini_cache, toplevel_dir)) {
+        // Store the promise so concurrent callers for the same dir share one read.
+        ini_cache[toplevel_dir] = read_config(toplevel_dir).then(function(r) { return r.rapydscript || {}; });
+    }
+    return ini_cache[toplevel_dir];
 }
 
 export async function cli(argv, base_path, src_path, lib_path) {
@@ -716,7 +717,52 @@ export async function cli(argv, base_path, src_path, lib_path) {
         return x === '-' ? argv.stdin_filename : x;
     }
 
-    for (const filename of (files.length ? files : [null])) {
+    // reportcb used for final output (same logic as inside lint_code)
+    var reportcb = {'json': cli_json_report, 'vim': cli_vim_report, 'undef': cli_undef_report}[argv.errorformat] || cli_report;
+
+    // Expand directories to .pyj files recursively, stat-ing entries in parallel.
+    async function expand_dirs(inputs, toplevel) {
+        // Stat all entries concurrently, then process results in sorted order.
+        var entries = await Promise.all(inputs.map(async function(f) {
+            if (f === '-') return { f, type: 'stdin' };
+            var st;
+            try { st = await fs.promises.lstat(f); }
+            catch (e) {
+                if (toplevel) { console.error("ERROR: can't access: " + f); process.exit(1); }
+                return null;
+            }
+            if (st.isDirectory()) return { f, type: 'dir' };
+            if (st.isFile()) return { f, type: 'file' };
+            return null;
+        }));
+
+        var result = [];
+        for (var i = 0; i < entries.length; i++) {
+            var entry = entries[i];
+            if (!entry) continue;
+            if (entry.type === 'stdin') { result.push(entry.f); continue; }
+            if (entry.type === 'file') { result.push(entry.f); continue; }
+            // Directory: read children and recurse
+            var children;
+            try {
+                children = (await fs.promises.readdir(entry.f)).sort().map(function(x) { return path.join(entry.f, x); });
+            } catch(e) {
+                if (toplevel) { console.error("ERROR: can't read directory: " + entry.f); process.exit(1); }
+                continue;
+            }
+            var sub = await expand_dirs(children, false);
+            sub.forEach(function(x) { if (x.endsWith('.pyj')) result.push(x); });
+        }
+        return result;
+    }
+    if (files.length) files = await expand_dirs(files, true);
+
+    var all_files = files.length ? files : [null];
+    var has_stdin = all_files.indexOf('-') !== -1 || all_files.indexOf(null) !== -1;
+
+    // Process a single file and return its messages without printing them.
+    // Used when the worker pool is not active (stdin, or too few files).
+    async function process_file(filename) {
         var code;
         try {
             code = await read_whole_file(filename === '-' ? null : filename);
@@ -747,10 +793,90 @@ export async function cli(argv, base_path, src_path, lib_path) {
             }
         });
 
-        // Lint!
-        if ((await lint_code(code, {filename:path_for_filename(filename || '-'), builtins:final_builtins, noqa:final_noqa, errorformat:argv.errorformat || false})).length) all_ok = false;
+        var lines = code.split('\n');
+        var msgs = await lint_code(code, {filename:path_for_filename(filename || '-'), builtins:final_builtins, noqa:final_noqa, errorformat:argv.errorformat || false, report:function() {}});
+        msgs.forEach(function(msg) { msg.code_lines = lines; });
+        return msgs;
+    }
+
+    var all_results;
+    // Use a worker pool when there are enough files to justify the overhead.
+    // Workers own their own compiler instance so parsing runs in parallel across CPU cores.
+    var WORKER_THRESHOLD = 4;
+
+    // In compiled binaries lint.mjs is dynamically imported so Bun's static
+    // analysis never sees the new Worker() call.  build.ts pre-bundles
+    // lint-worker.mjs and embeds it via `with { type: 'file' }`, storing the
+    // virtual-FS path in __rapydscript_embedded__['lint-worker-url'].
+    // Fall back gracefully (single-threaded) if the URL isn't available.
+    var embedded = globalThis.__rapydscript_embedded__;
+    var worker_url = embedded
+        ? embedded['lint-worker-url']
+        : new URL('./lint-worker.mjs', import.meta.url);
+
+    if (!has_stdin && all_files.length >= WORKER_THRESHOLD && worker_url) {
+        var { Worker } = await import('worker_threads');
+        var os_mod = await import('os');
+        var num_workers = Math.min(os_mod.cpus().length, all_files.length, 8);
+
+        // Dispatch files to workers dynamically so fast files don't leave workers idle.
+        var ordered_results = new Array(all_files.length);
+        var next_idx = 0;
+        var pending = all_files.length;
+        var done_resolve;
+        var done_promise = new Promise(function(res) { done_resolve = res; });
+        if (pending === 0) done_resolve();
+
+        function dispatch(worker) {
+            if (next_idx >= all_files.length) return;
+            var idx = next_idx++;
+            worker.postMessage({
+                type: 'lint',
+                id: idx,
+                filename: all_files[idx],
+                base_builtins: builtins,
+                base_noqa: noqa,
+            });
+        }
+
+        // Create workers and dispatch eagerly as each becomes ready rather than
+        // waiting for all workers before starting any work.
+        var worker_promises = Array.from({length: num_workers}, function() {
+            return new Promise(function(resolve) {
+                var w = new Worker(worker_url, { workerData: { embedded: embedded || null } });
+                w.once('message', function(m) {
+                    if (m.type !== 'ready') return;
+                    w.on('message', function(msg) {
+                        if (msg.type === 'result') {
+                            ordered_results[msg.id] = msg.messages;
+                        } else if (msg.type === 'error') {
+                            console.error("ERROR: lint failed for " + all_files[msg.id] + ": " + msg.error);
+                            ordered_results[msg.id] = [];
+                        }
+                        pending--;
+                        if (pending === 0) { done_resolve(); return; }
+                        dispatch(w);
+                    });
+                    dispatch(w);
+                    resolve(w);
+                });
+            });
+        });
+
+        await done_promise;
+        var workers = await Promise.all(worker_promises);
+        workers.forEach(function(w) { w.terminate(); });
+        all_results = ordered_results;
+    } else {
+        // Single-threaded path: process concurrently on the main thread.
+        all_results = await Promise.all(all_files.map(process_file));
     }
 
+    var all_messages = [];
+    all_results.forEach(function(msgs) { Array.prototype.push.apply(all_messages, msgs); });
+    if (all_messages.length) all_ok = false;
+    all_messages.forEach(function(msg, i) { reportcb(msg, i, all_messages); });
+
     process.exit((all_ok) ? 0 : 1);
 }
 // }}}

package/tools/lsp.mjs

@@ -230,7 +230,7 @@ export async function compute_diagnostics(ctx, uri, raw_text) {
     // 2. Linter diagnostics -- only when the file parsed cleanly, so we do not
     //    emit misleading undefined/unused warnings from a partial AST.
     if (a.toplevel && (!a.recovered_errors || a.recovered_errors.length === 0)) {
-        var builtins = utils.merge(BUILTINS);
+        var builtins = utils.merge(BUILTINS, file_globals(a.text));
         var messages = lint_parsed(a.toplevel, a.text, { filename: a.file_path, builtins: builtins, noqa: file_noqa(a.text) });
         messages.forEach(function (m) {
             out.push(lint_message_to_diagnostic(doc, m));
@@ -265,6 +265,16 @@ function file_noqa(code) {
     return noqa;
 }
 
+// Parse `# globals: a,b` file-level directives from the first lines (mirrors lint cli).
+function file_globals(code) {
+    var globals = Object.create(null);
+    code.split('\n', 20).forEach(function (line) {
+        var lq = line.replace(/\s+/g, '');
+        if (lq.slice(0, 9).toLowerCase() === '#globals:') (lq.split(':', 2)[1] || '').split(',').forEach(function (x) { if (x) globals[x] = true; });
+    });
+    return globals;
+}
+
 function lint_message_to_diagnostic(doc, m) {
     var start_line = (m.start_line || 1) - 1;
     var start_col = (m.start_col === undefined || m.start_col === null) ? 0 : m.start_col;

package/tree-sitter/grammar.js

@@ -57,6 +57,9 @@ module.exports = grammar({
     $._indent,
     $._dedent,
     $.regex,
+    $.fstring_start,
+    $.fstring_content,
+    $.fstring_end,
   ],
 
   extras: $ => [
@@ -589,6 +592,7 @@ module.exports = grammar({
       $.none,
       $.number,
       $.string,
+      $.f_string,
       $.concatenated_string,
       $.regex,
       $.verbatim,
@@ -924,20 +928,37 @@ module.exports = grammar({
     // ---- atoms / literals ------------------------------------------------
 
     concatenated_string: $ => prec.left(seq(
-      $.string,
-      repeat1($.string),
+      choice($.string, $.f_string),
+      repeat1(choice($.string, $.f_string)),
     )),
 
+    f_string: $ => seq(
+      $.fstring_start,
+      repeat(choice(
+        $.fstring_content,
+        $.interpolation,
+      )),
+      $.fstring_end,
+    ),
+
+    interpolation: $ => seq(
+      '{',
+      field('expression', $._expression),
+      optional(field('type_conversion', /![rsa]/)),
+      optional(seq(':', field('format_spec', $.fstring_content))),
+      '}',
+    ),
+
     this: _ => 'this',
     true: _ => 'True',
     false: _ => 'False',
     none: _ => 'None',
 
-    // string with optional r/u/f/b modifiers (the `v` modifier denotes a
-    // verbatim JavaScript literal and is handled separately). Interpolation
-    // and escapes are not sub-tokenised; the whole literal is a single node.
+    // string with optional r/u/b modifiers (the `v` modifier denotes a
+    // verbatim JavaScript literal, handled separately; the `f` modifier
+    // produces an f_string with structured interpolation nodes).
     string: _ => token(seq(
-      optional(/[rRuUfFbB]+/),
+      optional(/[rRuUbB]+/),
       choice(
         seq('"""', repeat(choice(/[^"\\]/, /\\(.|\n)/, /"[^"]/, /""[^"]/)), '"""'),
         seq("'''", repeat(choice(/[^'\\]/, /\\(.|\n)/, /'[^']/, /''[^']/)), "'''"),

package/tree-sitter/queries/highlights.scm

@@ -21,6 +21,16 @@
 (regex) @string.regexp
 (number) @number
 
+; f-strings: delimiters and literal content get @string, interpolation braces
+; get @punctuation.special so they stand out, and the expression inside is
+; transparent — its child nodes (identifiers, calls, etc.) are highlighted by
+; the normal rules below.
+(fstring_start) @string
+(fstring_content) @string
+(fstring_end) @string
+(interpolation "{" @punctuation.special)
+(interpolation "}" @punctuation.special)
+
 (true) @boolean
 (false) @boolean
 (none) @constant.builtin