rapydscript-ng 0.8.2 → 0.8.3

package/release/signatures.json

@@ -1,5 +1,5 @@
 {
-    "ast": "83fe570708f4a25ee630120ec1d2a1f47b39bd2f",
+    "ast": "6c918899920124616fcf87f30c2db475bf05d7b4",
     "baselib-builtins": "0e170c877a1bcc67e506df0ba64037bf1a2f6121",
     "baselib-containers": "39d05f99eb7cc741e44871ccc6acea868ee70ec8",
     "baselib-errors": "7f786439249e7d06cc010757f1bbaa6a2c3ea019",
@@ -13,9 +13,9 @@
     "output/codegen": "ff6f50e4533271e30ca55aff80c18f244d1c0f22",
     "output/comments": "b3baa47c00c1983ee54e912c602b58318e9c2bde",
     "output/exceptions": "7b9548eab7d67991c4932746a0ce766e07e9ac8d",
-    "output/functions": "a213dd5b806410c6575a78488cf813b4e8ddb1e9",
+    "output/functions": "1a88ea89a36366d958d0a6dcf5d3477775197702",
     "output/literals": "50a034dbdf6fca16de7b5147a7fd64faeb461255",
-    "output/loops": "47a2767193ba5f996808ee05927844a551cf022b",
+    "output/loops": "567b34e2f81c92512482cdbdfa59e90c5cb1ea38",
     "output/modules": "e2c2d92c714c31face3470de7ae8a61275a95fcd",
     "output/operators": "f45450104ed5def1298cf9a4962492ffeca02e63",
     "output/statements": "a56a432dee96d9ed0e490fc024ed8a99d30a5d0c",
@@ -23,9 +23,9 @@
     "output/utils": "97837ab9091710059e2ba01e245ee05fec82cd29",
     "parse": "0965e0416ea81d2b4bce422729b662022c0c4eb4",
     "string_interpolation": "9cc04ded68b82174728873f7df96aed60a4fb478",
-    "tokenizer": "4b38255101868598070367bcde7a11aea0c18276",
+    "tokenizer": "3c70e79fbe95b1f2d3164da4c96274b0d352d533",
     "unicode_aliases": "79ac6eaa5e6be44a5397d62c561f854a8fe7528e",
     "utils": "0cbca1fa76442212e31644f95a4f6e9a0317234f",
-    "#compiler#": "adbd3a6d4a70a98f08be2be192009164746efc68",
-    "#compiled_with#": "adbd3a6d4a70a98f08be2be192009164746efc68"
+    "#compiler#": "b3aec6fc48ac89b11c2c190d5fc03c3e688ede69",
+    "#compiled_with#": "b3aec6fc48ac89b11c2c190d5fc03c3e688ede69"
 }

package/src/ast.pyj

@@ -129,15 +129,13 @@ class AST_Directive(AST_Statement):
     'Represents a directive, like "use strict";'
     properties = {
         'value': "[string] The value of this directive as a plain string (it's not an AST_String!)",
-        'scope': '[AST_Scope/S] The scope that this directive affects'
+        'scope': '[AST_Scope/S] The scope that this directive affects',
     }
 
 
 class AST_SimpleStatement(AST_Statement):
     'A statement consisting of an expression, i.e. a = 1 + 2'
-    properties = {
-        'body': '[AST_Node] an expression node (should not be instanceof AST_Statement)'
-    }
+    properties = {'body': '[AST_Node] an expression node (should not be instanceof AST_Statement)'}
 
     def _walk(self, visitor):
         return visitor._visit(self, def ():
@@ -196,9 +194,7 @@ class AST_EmptyStatement(AST_Statement):
 
 class AST_StatementWithBody(AST_Statement):
     'Base class for all statements that contain one nested body: `For`, `ForIn`, `Do`, `While`, `With`'
-    properties = {
-        'body': "[AST_Statement] the body; this should always be present, even if it's an AST_EmptyStatement"
-    }
+    properties = {'body': "[AST_Statement] the body; this should always be present, even if it's an AST_EmptyStatement"}
 
     def _walk(self, visitor):
         return visitor._visit(self, def ():
@@ -208,9 +204,7 @@ class AST_StatementWithBody(AST_Statement):
 
 class AST_DWLoop(AST_StatementWithBody):
     'Base class for do/while statements'
-    properties = {
-        'condition': '[AST_Node] the loop condition.  Should not be instanceof AST_Statement'
-    }
+    properties = {'condition': '[AST_Node] the loop condition.  Should not be instanceof AST_Statement'}
 
     def _walk(self, visitor):
         return visitor._visit(self, def ():
@@ -256,7 +250,7 @@ class AST_ListComprehension(AST_ForIn):
     'A list comprehension expression'
     properties = {
         'condition': '[AST_Node] the `if` condition',
-        'statement': '[AST_Node] statement to perform on each element before returning it'
+        'statement': '[AST_Node] statement to perform on each element before returning it',
     }
 
     def _walk(self, visitor):
@@ -498,9 +492,7 @@ class AST_Jump(AST_Statement):
 
 class AST_Exit(AST_Jump):
     'Base class for “exits” (`return` and `throw`)'
-    properties = {
-        'value': '[AST_Node?] the value returned or thrown by this statement; could be null for AST_Return'
-    }
+    properties = {'value': '[AST_Node?] the value returned or thrown by this statement; could be null for AST_Return'}
 
     def _walk(self, visitor):
         return visitor._visit(self, def ():
@@ -555,7 +547,7 @@ class AST_If(AST_StatementWithBody):
     'A `if` statement'
     properties = {
         'condition': '[AST_Node] the `if` condition',
-        'alternative': '[AST_Statement?] the `else` part, or null if not present'
+        'alternative': '[AST_Statement?] the `else` part, or null if not present',
     }
 
     def _walk(self, visitor):
@@ -840,7 +832,7 @@ class AST_Splice(AST_PropAccess):
     'Index-style property access, i.e. `a[3:5]`'
     properties = {
         'property2': '[AST_Node] the 2nd property to access - typically ending index for the array.',
-        'assignment': '[AST_Node] The data being spliced in.'
+        'assignment': '[AST_Node] The data being spliced in.',
     }
 
     def _walk(self, visitor):
@@ -919,10 +911,10 @@ class AST_Assign(AST_Binary):
     'An assignment expression — `a = b + 5`'
 
     def is_chained(self):
-        return is_node_type(self.right, AST_Assign) or (
-            is_node_type(self.right, AST_Seq) and (
-                is_node_type(self.right.car, AST_Assign) or is_node_type(self.right.cdr, AST_Assign))
-        )
+        return is_node_type(
+            self.right,
+            AST_Assign
+        ) or (is_node_type(self.right, AST_Seq) and (is_node_type(self.right.car, AST_Assign) or is_node_type(self.right.cdr, AST_Assign)))
 
     def traverse_chain(self):
         right = self.right
@@ -1056,7 +1048,7 @@ class AST_Symbol(AST_Node):
     properties = {
         'name': '[string] name of this symbol',
         'scope': '[AST_Scope/S] the current scope (not necessarily the definition scope)',
-        'thedef': '[SymbolDef/S] the definition of this symbol'
+        'thedef': '[SymbolDef/S] the definition of this symbol',
     }
 
 
@@ -1088,9 +1080,7 @@ class AST_SymbolNonlocal(AST_SymbolDeclaration):
 
 class AST_SymbolFunarg(AST_SymbolVar):
     'Symbol naming a function argument, possibly with an annotation.'
-    properties = {
-        'annotation': '[AST_Node?] The annotation provided for this argument (if any)'
-    }
+    properties = {'annotation': '[AST_Node?] The annotation provided for this argument (if any)'}
 
 
 class AST_SymbolDefun(AST_SymbolDeclaration):
@@ -1242,7 +1232,10 @@ class TreeWalker:
             if is_node_type(p, AST_If) and p.condition is self
             or is_node_type(p, AST_Conditional) and p.condition is self
             or is_node_type(p, AST_DWLoop) and p.condition is self
-            or is_node_type(p, AST_UnaryPrefix) and p.operator is '!' and p.expression is self:
+            or is_node_type(
+                p,
+                AST_UnaryPrefix
+            ) and p.operator is '!' and p.expression is self:
                 return True
             if not (is_node_type(p, AST_Binary) and (p.operator is '&&' or p.operator is '||')):
                 return False

package/src/output/functions.pyj

@@ -5,7 +5,6 @@ from __python__ import hash_literals
 from ast import AST_ClassCall, AST_New, has_calls, AST_Dot, AST_SymbolRef, is_node_type
 from output.operators import print_getattr
 from output.statements import print_bracketed
-from output.stream import OutputStream
 from output.utils import create_doctring
 
 anonfunc = 'ρσ_anonfunc'
@@ -63,14 +62,59 @@ def function_preamble(node, output, offset):
             output.space()
             output.assign(arg)
             if Object.prototype.hasOwnProperty.call(a.defaults, arg.name):
-                output.spaced('(arguments[' + i + ']', '===', 'undefined', '||',
-                                '(', i, '===', 'arguments.length-1', '&&', kw, '!==', 'null', '&&', 'typeof', kw, '===', '"object"', '&&',
-                                kw, '[ρσ_kwargs_symbol]', '===', 'true))', '?', '')
+                output.spaced(
+                    '(arguments[' + i + ']',
+                    '===',
+                    'undefined',
+                    '||',
+                    '(',
+                    i,
+                    '===',
+                    'arguments.length-1',
+                    '&&',
+                    kw,
+                    '!==',
+                    'null',
+                    '&&',
+                    'typeof',
+                    kw,
+                    '===',
+                    '"object"',
+                    '&&',
+                    kw,
+                    '[ρσ_kwargs_symbol]',
+                    '===',
+                    'true))',
+                    '?',
+                    ''
+                )
                 output.print(fname + '.__defaults__.'), arg.print(output)
                 output.space(), output.print(':'), output.space()
             else:
-                output.spaced('(', i, '===', 'arguments.length-1', '&&', kw, '!==', 'null', '&&', 'typeof', kw, '===', '"object"', '&&',
-                                kw, '[ρσ_kwargs_symbol]', '===', 'true)', '?', 'undefined', ':', '')
+                output.spaced(
+                    '(',
+                    i,
+                    '===',
+                    'arguments.length-1',
+                    '&&',
+                    kw,
+                    '!==',
+                    'null',
+                    '&&',
+                    'typeof',
+                    kw,
+                    '===',
+                    '"object"',
+                    '&&',
+                    kw,
+                    '[ρσ_kwargs_symbol]',
+                    '===',
+                    'true)',
+                    '?',
+                    'undefined',
+                    ':',
+                    ''
+                )
             output.print('arguments[' + i + ']')
             output.end_statement()
     if a.kwargs or a.has_defaults:
@@ -81,13 +125,35 @@ def function_preamble(node, output, offset):
         output.end_statement()
         # Ensure kwargs is the options object
         output.indent()
-        output.spaced('if', '(' + kw, '===', 'null', '||', 'typeof', kw, '!==', '"object"', '||', kw, '[ρσ_kwargs_symbol]', '!==', 'true)', kw, '=', '{}')
+        output.spaced(
+            'if',
+            '(' + kw,
+            '===',
+            'null',
+            '||',
+            'typeof',
+            kw,
+            '!==',
+            '"object"',
+            '||',
+            kw,
+            '[ρσ_kwargs_symbol]',
+            '!==',
+            'true)',
+            kw,
+            '=',
+            '{}'
+        )
         output.end_statement()
         # Read values from the kwargs object for any formal parameters
         if a.has_defaults:
             for dname in Object.keys(a.defaults):
                 output.indent()
-                output.spaced('if', '(Object.prototype.hasOwnProperty.call(' + kw + ',', '"' + dname + '"))')
+                output.spaced(
+                    'if',
+                    '(Object.prototype.hasOwnProperty.call(' + kw + ',',
+                    '"' + dname + '"))'
+                )
                 output.with_block(def ():
                     output.indent()
                     output.spaced(dname, '=', kw + '.' + dname)
@@ -103,11 +169,33 @@ def function_preamble(node, output, offset):
         # Define the *args parameter, putting in whatever is left after assigning the formal parameters and the options object
         nargs = a.args.length - offset
         output.indent()
-        output.spaced('var', a.starargs.name, '=', 'Array.prototype.slice.call(arguments,', nargs + ')')
+        output.spaced(
+            'var',
+            a.starargs.name,
+            '=',
+            'Array.prototype.slice.call(arguments,',
+            nargs + ')'
+        )
         output.end_statement()
         # Remove the options object, if present
         output.indent()
-        output.spaced('if', '(' + kw, '!==', 'null', '&&', 'typeof', kw, '===', '"object"', '&&', kw, '[ρσ_kwargs_symbol]', '===', 'true)', a.starargs.name)
+        output.spaced(
+            'if',
+            '(' + kw,
+            '!==',
+            'null',
+            '&&',
+            'typeof',
+            kw,
+            '===',
+            '"object"',
+            '&&',
+            kw,
+            '[ρσ_kwargs_symbol]',
+            '===',
+            'true)',
+            a.starargs.name
+        )
         output.print('.pop()')
         output.end_statement()
 
@@ -183,7 +271,11 @@ def function_annotation(self, output, strip_first, name):
     output.indent()
     # Only define the properties if they were not already defined, which
     # can happen if the function definition is inside a loop, for example.
-    output.spaced('if', '(!' + fname + '.' + names[0] + ')', 'Object.defineProperties(' + fname)
+    output.spaced(
+        'if',
+        '(!' + fname + '.' + names[0] + ')',
+        'Object.defineProperties(' + fname
+    )
     output.comma()
     output.with_block(def ():
         for v'var i = 0; i < names.length; i++':
@@ -235,7 +327,10 @@ def function_definition(self, output, strip_first, as_expression):
     if as_expression:
         output.end_statement()
         function_annotation(self, output, strip_first, anonfunc)
-        output.indent(), output.spaced('return', anonfunc), output.end_statement()
+        output.indent(), output.spaced(
+            'return',
+            anonfunc
+        ), output.end_statement()
         output.set_indentation(orig_indent)
         output.indent(), output.print('})()')
 
@@ -386,7 +481,10 @@ def print_function_call(self, output):
 
     is_repeatable = is_new or not has_calls(self.expression)
     if not is_repeatable:
-        output.assign('(ρσ_expr_temp'), print_this(self.expression, output), output.comma()
+        output.assign('(ρσ_expr_temp'), print_this(
+            self.expression,
+            output
+        ), output.comma()
 
     if has_kwargs:
         if is_new:

package/src/output/loops.pyj

@@ -3,7 +3,6 @@
 from __python__ import hash_literals
 
 from ast import AST_BaseCall, AST_SymbolRef, AST_Array, AST_Unary, AST_Number, has_calls, AST_Seq, AST_ListComprehension, is_node_type
-from output.stream import OutputStream
 
 
 def unpack_tuple(elems, output, in_statement):
@@ -55,10 +54,7 @@ def is_simple_for(self):
             not (is_node_type(self.init, AST_Array))):
         a = self.object.args.args
         l = a.length
-        if l < 3 or (
-            is_node_type(a[2].value, AST_Number) or (
-                is_node_type(a[2].value, AST_Unary) and a[2].value.operator is '-' and is_node_type(a[2].value.expression, AST_Number)
-        )):
+        if l < 3 or (is_node_type(a[2].value, AST_Number) or (is_node_type(a[2].value, AST_Unary) and a[2].value.operator is '-' and is_node_type(a[2].value.expression, AST_Number))):
             if (l is 1 and not has_calls(a[0].value)) or (l > 1 and not has_calls(a[1].value)):
                 return True
     return False
@@ -99,8 +95,24 @@ def print_for_loop_body(output):
 
 def init_es6_itervar(output, itervar):
     output.indent()
-    output.spaced(itervar, '=', '((typeof', itervar + '[Symbol.iterator]', '===', '"function")', '?',
-                    '(' + itervar, 'instanceof', 'Map', '?', itervar + '.keys()', ':', itervar + ')', ':', 'Object.keys(' + itervar + '))')
+    output.spaced(
+        itervar,
+        '=',
+        '((typeof',
+        itervar + '[Symbol.iterator]',
+        '===',
+        '"function")',
+        '?',
+        '(' + itervar,
+        'instanceof',
+        'Map',
+        '?',
+        itervar + '.keys()',
+        ':',
+        itervar + ')',
+        ':',
+        'Object.keys(' + itervar + '))'
+    )
     output.end_statement()
 
 
@@ -176,7 +188,13 @@ def print_for_in(self, output):
         output.end_statement()
         init_es6_itervar(output, itervar)
         output.indent()
-        output.spaced('for', '(var', 'ρσ_Index' + output.index_counter, 'of', itervar + ')')
+        output.spaced(
+            'for',
+            '(var',
+            'ρσ_Index' + output.index_counter,
+            'of',
+            itervar + ')'
+        )
 
     output.space()
     self._do_print_body(output)
@@ -184,7 +202,11 @@ def print_for_in(self, output):
 
 def print_list_comprehension(self, output):
     tname = self.constructor.name.slice(4)
-    result_obj = {'ListComprehension': '[]', 'DictComprehension': ('Object.create(null)' if self.is_jshash else '{}'), 'SetComprehension': 'ρσ_set()'}[tname]
+    result_obj = {
+        'ListComprehension': '[]',
+        'DictComprehension': ('Object.create(null)' if self.is_jshash else '{}'),
+        'SetComprehension': 'ρσ_set()',
+    }[tname]
     is_generator = tname is 'GeneratorComprehension'
     if tname is 'DictComprehension':
         if self.is_pydict:

package/src/tokenizer.pyj

@@ -503,9 +503,15 @@ def tokenizer(raw_text, filename, recover_errors):
             parts = v'[quoted_string(string)]'
         # Look ahead for consecutive string literals to concatenate (e.g. f'a'f'b' or f'a''b')
         while True:
-            # Skip horizontal whitespace (spaces and tabs, not newlines)
-            while S.pos < S.text.length and (S.text.charAt(S.pos) is ' ' or S.text.charAt(S.pos) is '\t'):
-                next()
+            # Skip horizontal whitespace; also skip newlines inside brackets where indentation is irrelevant
+            while S.pos < S.text.length:
+                wch = S.text.charAt(S.pos)
+                if wch is ' ' or wch is '\t':
+                    next()
+                elif (wch is '\n' or wch is '\r') and not S.indentation_matters[-1]:
+                    next()
+                else:
+                    break
             ch = S.text.charAt(S.pos)
             if not ch:
                 break
@@ -676,8 +682,14 @@ def tokenizer(raw_text, filename, recover_errors):
             # otherwise be parsed as a call expression "a"(...) after the tokenizer
             # injects the f-string result as a parenthesised expression.
             j = S.pos
-            while j < S.text.length and (S.text.charAt(j) is ' ' or S.text.charAt(j) is '\t'):
-                j += 1
+            while j < S.text.length:
+                jch = S.text.charAt(j)
+                if jch is ' ' or jch is '\t':
+                    j += 1
+                elif (jch is '\n' or jch is '\r') and not S.indentation_matters[-1]:
+                    j += 1
+                else:
+                    break
             if j < S.text.length and is_identifier_start(S.text.charAt(j).charCodeAt(0)):
                 k = j
                 while k < S.text.length and is_identifier_char(S.text.charAt(k)):

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/lint-worker.mjs

@@ -0,0 +1,101 @@
+/* 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 } 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);
+
+// 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) });
+    }
+});