crossbind 2.0.0-beta.74 → 2.0.0-beta.76

package/src/utils/bridgeRuntimeFixes.js

@@ -1,3 +1,25 @@
+// A const char* followed by an integer may be a byte span, with embedded NULs or no terminator.
+// Preserve its address; JavaScript can read exactly the reported length with readBuffer. The argument keeps its const for
+// callbackArgument, which takes it by reference: a callback's const std::vector<std::string> & binds to no other.
+const CALLBACK_ARGUMENT_AT = `template<size_t I, typename Tuple> auto callbackArgumentAt(Tuple values) {
+  using Arg = std::remove_reference_t<decltype(std::get<I>(values))>;
+  using A = std::remove_cv_t<Arg>;
+  if constexpr (std::is_same_v<A, const char *> && I + 1 < std::tuple_size_v<Tuple>) {
+    using Next = std::remove_cv_t<std::remove_reference_t<decltype(std::get<I + 1>(values))>>;
+    if constexpr (std::is_integral_v<Next>) return toHandle(std::get<I>(values));
+    else return callbackArgument<Arg>(std::get<I>(values));
+  } else return callbackArgument<Arg>(std::get<I>(values));
+}`;
+// The form a bridge cached before the argument kept its const still holds.
+const CALLBACK_ARGUMENT_AT_WITHOUT_CONST = `template<size_t I, typename Tuple> auto callbackArgumentAt(Tuple values) {
+  using A = std::remove_cv_t<std::remove_reference_t<decltype(std::get<I>(values))>>;
+  if constexpr (std::is_same_v<A, const char *> && I + 1 < std::tuple_size_v<Tuple>) {
+    using Next = std::remove_cv_t<std::remove_reference_t<decltype(std::get<I + 1>(values))>>;
+    if constexpr (std::is_integral_v<Next>) return toHandle(std::get<I>(values));
+    else return callbackArgument<A>(std::get<I>(values));
+  } else return callbackArgument<A>(std::get<I>(values));
+}`;
+
 // Adapt the runtime emitted by the pinned SWIG fork. Kept in the generator so cache rebuilds
 // produce the same runtime in every bridge, including builds on a remote runner.
 export default function fixBridgeRuntime(text) {
@@ -22,16 +44,7 @@ template<typename T> constexpr bool isPassedByAddress =`);
     }
     if (!text.includes('auto callbackArgumentAt(')) {
         text = '#include <tuple>\n' + text;
-        text = text.replace('#ifndef __EMSCRIPTEN__\nstruct RuntimeCallbacks {', `// A const char* followed by an integer may be a byte span, with embedded NULs or no terminator.
-// Preserve its address; JavaScript can read exactly the reported length with readBuffer.
-template<size_t I, typename Tuple> auto callbackArgumentAt(Tuple values) {
-  using A = std::remove_cv_t<std::remove_reference_t<decltype(std::get<I>(values))>>;
-  if constexpr (std::is_same_v<A, const char *> && I + 1 < std::tuple_size_v<Tuple>) {
-    using Next = std::remove_cv_t<std::remove_reference_t<decltype(std::get<I + 1>(values))>>;
-    if constexpr (std::is_integral_v<Next>) return toHandle(std::get<I>(values));
-    else return callbackArgument<A>(std::get<I>(values));
-  } else return callbackArgument<A>(std::get<I>(values));
-}
+        text = text.replace('#ifndef __EMSCRIPTEN__\nstruct RuntimeCallbacks {', `${CALLBACK_ARGUMENT_AT}
 #ifndef __EMSCRIPTEN__
 struct RuntimeCallbacks {`);
         text = text.replaceAll('template<typename R, typename... A> R invokeCallback(size_t slot, A... args) {',
@@ -44,5 +57,5 @@ struct RuntimeCallbacks {`);
 }
 template<typename F> struct Callback {`);
     }
-    return text;
+    return text.replace(CALLBACK_ARGUMENT_AT_WITHOUT_CONST, CALLBACK_ARGUMENT_AT);
 }

package/src/utils/embindPointerOwners.js

@@ -0,0 +1,42 @@
+// A pointer a member function or property hands out can point into the object it was called on, as a getter of a
+// member behind a unique_ptr does, or name that object, as a fluent call does. JavaScript frees the object once
+// nothing reaches its handle (utils/embindObjectLifetime.js), and the pointer then reads freed memory. The handle of
+// such a pointer holds a clone of the object's handle, on the count the pointer's clones share, so the object goes
+// with the last of them. Only a raw pointer, a NativePointer and an emscripten::val can borrow: a copy and a smart
+// pointer hold what they point at. Static methods and free functions have no object to hold.
+
+const HELPERS = 'function crossbindMayBorrow(type){if(!type)return false;if(type.name==="emscripten::val")return true;'
+    + 'var cls=type.registeredClass;return!!cls&&!type.isReference&&(!type.isSmartPointer||cls.name==="NativePointer")}'
+    + 'function crossbindKeepOwner(value,owner){var $$=value&&value.$$;var held=owner&&owner.$$;'
+    + 'if(!$$||!$$.count||$$.count.owner||!held||!held.ptr||held.preservePointerOnDelete||$$.count===held.count)return value;'
+    + 'if($$.smartPtr?$$.ptrType.registeredClass.name==="NativePointer":!$$.count.owned)$$.count.owner=owner.clone();return value}'
+    + 'function crossbindKeepsOwner(fn,type){if(!crossbindMayBorrow(type))return fn;'
+    + 'var kept=function(...args){var owner=this;var value=fn.apply(owner,args);'
+    + 'return value instanceof Promise?value.then(resolved=>crossbindKeepOwner(resolved,owner)):crossbindKeepOwner(value,owner)};'
+    + 'Object.defineProperty(kept,"name",{value:fn.name});return kept}';
+
+// The release glue spells each on one line, the debug glue with spaces and quoted property names. A release glue
+// names embind's registrations by the minified keys of the wasm imports, so a glue that registers class methods is
+// known by the pure virtual check of the method registration, and one that registers properties by the getter's
+// `this` check.
+const CRAFT = /function craftInvokerFunction\s*\(/;
+const MEMBER = /(var memberFunction\s*=\s*)(craftInvokerFunction\(\s*humanName,\s*argTypes,\s*classType,\s*rawInvoker,\s*context(?:,\s*isAsync)?\s*\))(\s*;)/g;
+const GETTER = /return (getterReturnType(?:\.fromWireType|\[['"]fromWireType['"]\])\(\s*getter\(\s*getterContext,\s*ptr\s*\)\s*\))/g;
+const METHODS = /pureVirtualFunctions\.push\(\s*methodName\s*\)/;
+const PROPERTIES = /humanName\s*\+\s*['"] getter['"]/;
+
+const count = (text, pattern) => text.match(pattern)?.length ?? 0;
+
+// Returns the rewritten glue and whether it binds class methods or properties this rewrite does not recognise.
+export function keepPointerOwners(glue) {
+    const hasMethods = METHODS.test(glue);
+    const hasProperties = PROPERTIES.test(glue);
+    if (!hasMethods && !hasProperties) return { text: glue, missed: false };
+    const recognised = CRAFT.test(glue) && (!hasMethods || count(glue, MEMBER) === 1) && (!hasProperties || count(glue, GETTER) === 1);
+    if (!recognised) return { text: glue, missed: true };
+    const text = glue
+        .replace(CRAFT, (craft) => `${HELPERS}${craft}`)
+        .replace(MEMBER, (_, assign, call, end) => `${assign}crossbindKeepsOwner(${call},argTypes[0])${end}`)
+        .replace(GETTER, (_, read) => `return crossbindKeepOwner(${read},this)`);
+    return { text, missed: false };
+}

package/src/utils/sourceFingerprint.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import { getContentHash } from './hash.js';
 import { recipePatchesFingerprint } from './recipePatches.js';
+import { ANDROID_STL } from './androidToolchain.js';
 
 // The prebuilt-lib cache in buildLib is existence-only, so a nativeVersion or recipe-sha256 bump
 // would otherwise be served from the previous build - shipping the old upstream under the new
@@ -10,8 +11,10 @@ export const SOURCE_FINGERPRINT_FILE = 'crossbind-source.fingerprint';
 export function getSourceFingerprint(config, target) {
     const nativeVersion = config?.package?.nativeVersion || null;
     const sha256 = config?.build?.sha256 || null;
+    // An Android library built while it linked libc++ in builds again against the shared runtime, of local sources too.
+    const androidRuntime = target?.platform === 'android' ? ANDROID_STL : null;
     // Local-source packages pin neither; buildLib checks their native source inventory instead.
-    if (!nativeVersion && !sha256) return null;
+    if (!nativeVersion && !sha256 && !androidRuntime) return null;
     const sourceReplacements = target ? config?.build?.sourceReplaceList?.(target, config.allDependencyPaths?.[target.path] ?? {}) : undefined;
     const patches = recipePatchesFingerprint(config?.build?.patches);
     return getContentHash(JSON.stringify({
@@ -19,6 +22,7 @@ export function getSourceFingerprint(config, target) {
         sha256,
         ...(sourceReplacements?.length ? { sourceReplacements } : {}),
         ...(patches ? { patches } : {}),
+        ...(androidRuntime ? { androidRuntime } : {}),
     }));
 }
 

package/src/utils/swigInterface.js

@@ -65,7 +65,7 @@ export function interfaceIncludes(headerPath, prelude = []) {
 // wraps just the imported header. The ignored declarations follow the macros, so the retry without macros keeps them.
 export function buildInterfaceContent({
     moduleName, headerPath, prelude = [], completing = [], swigMacros = [], ignored = [], constants = [], preamble = [], functions = ALL_NAMES,
-    extras = [],
+    classes = ALL_NAMES, extras = [],
 }) {
     const includes = [...new Set([...interfaceIncludes(headerPath, prelude), ...completing])]
         .map((header) => `#include "${header}"`)
@@ -89,7 +89,7 @@ ${extraBlock}%{
 ${includes}
 %}
 
-${everyConstant ? '' : constantRequests(constants)}${functionRequests(functions)}%feature("shared_ptr");
+${everyConstant ? '' : constantRequests(constants)}${functionRequests(functions)}${classRequests(classes)}%feature("shared_ptr");
 %feature("polymorphic_shared_ptr");
 
 ${macros}${ignores}${preambleBlock}${everyConstant ? constantRequests(constants) : ''}%include "${headerPath}"
@@ -104,17 +104,32 @@ function constantRequests(constants) {
     return constants.length ? `${constants.map((name) => `%feature("embind:constant") ${name};`).join('\n')}\n\n` : '';
 }
 
-// SWIG ignores every global function, then wraps the listed names again: class members, enums and constants stay. The
-// package's own ignores come after, since SWIG applies the later of two renames of a name.
+// SWIG ignores every global function, then wraps the listed names again: class members, enums and constants stay. A
+// function declared through a function typedef (OpenSSL's `OSSL_provider_init_fn OSSL_provider_init;`) reads as a
+// variable, so global variables are ignored too, as rule 10 binds a mutable one only when imported. The package's own
+// ignores come after, since SWIG applies the later of two renames of a name.
 function functionRequests(functions) {
     if (functions === ALL_NAMES) return '';
     const names = [...new Set(functions)].sort();
-    return `%rename($ignore, %$isfunction, %$isglobal) "";\n${names.map((name) => `%rename("%s") ${name};\n`).join('')}\n`;
+    return `%rename($ignore, %$isfunction, %$isglobal) "";\n%rename($ignore, %$isvariable, %$isglobal) "";\n${names.map((name) => `%rename("%s") ${name};\n`).join('')}\n`;
 }
 
-// Editor declarations need the whole header even when the compiled bridge selects functions by import.
+// SWIG ignores every class, then wraps the classes the app's imports reach (see typeClosure.js) again. A class outside
+// any namespace is wrapped as a class only, so a C function sharing its name (struct stat and stat()) stays out; SWIG
+// matches a namespace's class by its full name only without that condition.
+function classRequests(classes) {
+    if (classes === ALL_NAMES) return '';
+    const lines = [...new Set(classes)].sort()
+        .map((name) => (name.includes('::') ? `%rename("%s") ${name};\n` : `%rename("%s", %$isclass) ${name};\n`));
+    return `%rename($ignore, %$isclass) "";\n${lines.join('')}\n`;
+}
+
+// Editor declarations and SWIG's parse for the bindings plan need the whole header even when the compiled bridge
+// selects functions and classes by import.
 export function interfaceWithAllFunctions(content) {
-    return content.replace(/%rename\(\$ignore, %\$isfunction, %\$isglobal\) "";\n(?:%rename\("%s"\) [A-Za-z_]\w*;\n)*\n/g, '');
+    return content
+        .replace(/%rename\(\$ignore, %\$isfunction, %\$isglobal\) "";\n(?:%rename\(\$ignore, %\$isvariable, %\$isglobal\) "";\n)?(?:%rename\("%s"\) [A-Za-z_]\w*;\n)*\n/g, '')
+        .replace(/%rename\(\$ignore, %\$isclass\) "";\n(?:%rename\("%s"(?:, %\$isclass)?\) [A-Za-z_][\w:]*;\n)*\n/g, '');
 }
 
 export function withoutSwigMacros(content) {

package/src/utils/toolchainNotices.js

@@ -3,3 +3,23 @@
 export default function toolchainNoticesDir(platform) {
     return `toolchain-licenses/${platform}`;
 }
+
+// What a wasm build copies there (actions/wasmNotices.js).
+export const WASM_NOTICES = {
+    emscriptenText: 'emscripten-LICENSE',
+    llvmText: 'llvm-LICENSE.TXT',
+    emscriptenVersion: 'emscripten-version.txt',
+    llvmVersion: 'clang-version.txt',
+    image: 'image.txt',
+};
+
+// What a Linux, Windows or Android link copies there (actions/nativeNotices.js), beside a Windows image's mingw-w64
+// notices, which keep their names.
+export const NATIVE_NOTICES = {
+    llvmText: 'llvm-LICENSE.TXT',
+    clangVersion: 'clang-version.txt',
+    libcxxVersion: 'libcxx-version.txt',
+    mingwVersion: 'mingw-w64-version.txt',
+};
+
+export const MINGW_NOTICE = /^COPYING/;

package/src/utils/typeClosure.js

@@ -0,0 +1,170 @@
+import { ALL_NAMES } from './headerImports.js';
+
+// SWIG's own parse of a header (swig -xml), read for the classes a bridge has to register. embind registers each class
+// once, in the bridge of the header defining it, and a binding naming a class no bridge registers fails only when it is
+// called. So a header binds the classes its imported names reach: through their signatures, the bases of those classes
+// and the signatures of their public members, in this header and in the headers defining them.
+
+// SWIG leaves `>` unescaped inside attribute values (std::vector<(T)>), so a tag ends only outside a quoted value.
+const TAG = /<(\/?)([A-Za-z_][\w-]*)((?:\s+[\w:-]+="[^"]*")*)\s*(\/?)>/g;
+const ATTRIBUTE = /([\w:-]+)="([^"]*)"/g;
+const NAME = /[A-Za-z_]\w*(?:::[A-Za-z_]\w*)*/g;
+const ENTITIES = { lt: '<', gt: '>', amp: '&', quot: '"', apos: "'" };
+// SWIG's type strings spell pointers, references, qualifiers, functions and arrays as p. r. z. q(...). f(...). a(...).
+const NOT_TYPES = new Set([
+    'p', 'r', 'z', 'q', 'f', 'a', 'const', 'volatile', 'struct', 'class', 'union', 'enum', 'typename',
+    'unsigned', 'signed', 'char', 'short', 'int', 'long', 'float', 'double', 'void', 'bool', 'wchar_t', 'size_t',
+]);
+const EMPTY_TREE = { types: new Map(), values: new Map(), enumerators: new Map() };
+
+const decode = (text) => text.replace(/&(lt|gt|amp|quot|apos);/g, (entity, name) => ENTITIES[name]);
+
+function parse(xml) {
+    const root = { tag: 'root', attributes: {}, children: [] };
+    const open = [root];
+    for (const [, closing, tag, rest, selfClosing] of xml.matchAll(TAG)) {
+        if (closing) {
+            open.pop();
+            continue;
+        }
+        const attributes = Object.fromEntries([...rest.matchAll(ATTRIBUTE)].map(([, key, value]) => [key, decode(value)]));
+        const node = { tag, attributes, children: [] };
+        open.at(-1).children.push(node);
+        if (!selfClosing) open.push(node);
+    }
+    return root;
+}
+
+// A node's own attributes are the <attribute> elements of its first <attributelist>.
+const listOf = (node) => node.children.find((child) => child.tag === 'attributelist')?.children ?? [];
+const attributesOf = (node) => Object.fromEntries(listOf(node).filter((child) => child.tag === 'attribute')
+    .map((child) => [child.attributes.name, child.attributes.value]));
+const basesOf = (node) => listOf(node).filter((child) => child.tag === 'baselist')
+    .flatMap((list) => list.children.filter((child) => child.tag === 'base').map((base) => base.attributes.name));
+const parametersOf = (node) => listOf(node).filter((child) => child.tag === 'parmlist')
+    .flatMap((list) => list.children.filter((child) => child.tag === 'parm').map((parm) => attributesOf(parm).type ?? ''));
+
+// What a header declares: its classes, enums and typedefs by qualified name, each with the type strings it uses, its free
+// functions and variables by name, and the enum of each enumerator. SWIG binds no nested class and no member a class
+// keeps private, so neither reaches anything.
+export function readSwigTree(xml) {
+    const types = new Map();
+    const values = new Map();
+    const enumerators = new Map();
+    // C names a struct and its typedef alike (`typedef struct PJ_INFO PJ_INFO;` ahead of `struct PJ_INFO {...}`), and the
+    // name stands for the struct.
+    const declare = (name, entry) => {
+        if (!types.has(name) || (types.get(name).kind === 'typedef' && entry.kind !== 'typedef')) types.set(name, entry);
+    };
+    const visit = (node, namespace, owner) => {
+        // %$isclass leaves class templates alone, so the selection does too.
+        if (node.tag === 'template') return;
+        const own = node.tag === 'root' ? {} : attributesOf(node);
+        const isPublic = own.access !== 'private' && own.access !== 'protected';
+        // SWIG spells a class or enum by its full name; a typedef inside a namespace or class may be spelled without it.
+        const qualified = (name) => (name.includes('::') || !namespace.length ? name : [...namespace, name].join('::'));
+        if (node.tag === 'namespace') {
+            node.children.forEach((child) => visit(child, own.name ? [...namespace, own.name] : namespace, null));
+        } else if (node.tag === 'class') {
+            if (!own.name || !isPublic || own.nested === '1') return;
+            const name = qualified(own.name);
+            // The name SWIG binds it under: a C struct's typedef name (X509V3_CONF_METHOD for X509V3_CONF_METHOD_st).
+            const bound = own.sym_name ?? own['sym:name'] ?? own.tdname ?? name.split('::').at(-1);
+            const entry = { kind: 'class', scope: name.split('::'), bases: basesOf(node), uses: [], bound };
+            declare(name, entry);
+            node.children.forEach((child) => visit(child, namespace, entry));
+        } else if (node.tag === 'enum') {
+            if (!own.name || !isPublic) return;
+            const name = owner && !own.name.includes('::') ? [...owner.scope, own.name].join('::') : qualified(own.name);
+            declare(name, { kind: 'enum', scope: name.split('::'), bases: [], uses: [] });
+            node.children.filter((child) => child.tag === 'enumitem').forEach((item) => {
+                const enumerator = attributesOf(item).name;
+                if (enumerator && !enumerators.has(enumerator)) enumerators.set(enumerator, name);
+            });
+        } else if (node.tag === 'cdecl') {
+            if (!own.name || !isPublic || own.storage === 'friend') return;
+            const uses = [own.type ?? '', own.decl ?? '', ...parametersOf(node)];
+            if (own.storage === 'typedef') {
+                const name = owner ? [...owner.scope, own.name].join('::') : qualified(own.name);
+                declare(name, { kind: 'typedef', scope: name.split('::'), bases: [], uses });
+            } else if (owner) {
+                owner.uses.push(...uses);
+            } else {
+                // An import of an overloaded name binds every overload.
+                values.set(own.name, [...(values.get(own.name) ?? []), ...uses]);
+            }
+        } else if (node.tag === 'constructor') {
+            if (owner && isPublic) owner.uses.push(own.decl ?? '', ...parametersOf(node));
+        } else {
+            node.children.forEach((child) => visit(child, namespace, owner));
+        }
+    };
+    visit(parse(xml), [], null);
+    return { types, values, enumerators };
+}
+
+// The classes and enums `names` reach from `header`, by qualified name, each with its kind and the header defining it.
+// `treeOf` reads a header's parse; a name no header read so far declares is looked up through `definingHeader`, whose
+// header is read in turn. ALL_NAMES starts from everything the header declares, as a header bound whole does.
+export function typeClosure(header, names, { treeOf, definingHeader }) {
+    const trees = new Map();
+    const read = (file) => {
+        if (!trees.has(file)) trees.set(file, treeOf(file) ?? EMPTY_TREE);
+        return trees.get(file);
+    };
+    const root = read(header);
+    const lookedUp = new Set();
+    const inTrees = (candidates, wanted) => {
+        for (const candidate of candidates) {
+            for (const [file, tree] of trees) {
+                const entry = tree.types.get(candidate);
+                if (entry && wanted(entry)) return { name: candidate, file, entry };
+            }
+        }
+        return null;
+    };
+    const isClassOrEnum = (entry) => entry.kind !== 'typedef';
+    // A class or enum wins over a typedef of the same name, even one another header declares first (a forward header's
+    // `typedef struct Foo Foo;`), so a header that may define the name is read before a typedef stands for it.
+    const find = (candidates) => {
+        const found = inTrees(candidates, isClassOrEnum);
+        if (found) return found;
+        for (const candidate of candidates) {
+            if (lookedUp.has(candidate)) continue;
+            lookedUp.add(candidate);
+            const file = definingHeader(candidate);
+            if (file && !trees.has(file)) read(file);
+        }
+        return inTrees(candidates, isClassOrEnum) ?? inTrees(candidates, () => true);
+    };
+    const queue = [];
+    const reach = (text, scope) => {
+        for (const [name] of text.matchAll(NAME)) {
+            if (!NOT_TYPES.has(name)) queue.push({ name, scope });
+        }
+    };
+    const start = names === ALL_NAMES ? [...root.values.keys(), ...root.types.keys()] : names;
+    for (const name of start) {
+        if (root.values.has(name)) root.values.get(name).forEach((use) => reach(use, []));
+        else queue.push({ name: root.enumerators.get(name) ?? name, scope: [] });
+    }
+    const reached = new Map();
+    const visited = new Set();
+    while (queue.length) {
+        const { name, scope } = queue.pop();
+        // As in C++ lookup, a name used inside a class or namespace is tried there first.
+        const candidates = [...scope.map((_, depth) => [...scope.slice(0, scope.length - depth), name].join('::')), name];
+        const found = find(candidates);
+        if (!found || visited.has(found.name)) continue;
+        visited.add(found.name);
+        const { entry } = found;
+        if (entry.kind === 'class') reached.set(found.name, { kind: entry.kind, header: found.file, bound: entry.bound });
+        else if (entry.kind === 'enum') reached.set(found.name, { kind: entry.kind, header: found.file });
+        const enclosing = entry.scope.slice(0, -1);
+        // SWIG binds an enum declared in a class only with that class.
+        if (entry.kind === 'enum' && enclosing.length) queue.push({ name: enclosing.join('::'), scope: [] });
+        entry.bases.forEach((base) => queue.push({ name: base, scope: enclosing }));
+        entry.uses.forEach((use) => reach(use, entry.kind === 'class' ? entry.scope : enclosing));
+    }
+    return reached;
+}