zuzu-js 0.1.1 → 0.1.2

package/lib/cli.js

@@ -254,7 +254,7 @@ function stripShebang( source ) {
 }
 
 function printVersion( runtime, verbose ) {
-	process.stdout.write( 'zuzu-js version 0.1.1\n' );
+	process.stdout.write( 'zuzu-js version 0.1.2\n' );
 	if ( verbose ) {
 		process.stdout.write( '\nlib search paths:\n' );
 		for ( const p of runtime.getModuleSearchRoots() ) {

package/lib/runtime.js

@@ -1904,6 +1904,13 @@ function zuzuTypeMatches( value, typeName ) {
 		if ( typeName === 'PairList' ) {
 			return isPairListLike( value ) ? 1 : 0;
 		}
+		if ( typeName === 'Exception' ) {
+			const globalType = globalThis.Exception;
+			if ( globalType != null && zuzuInstanceof( value, globalType ) ) {
+				return 1;
+			}
+			return value instanceof Error ? 1 : 0;
+		}
 		return zuzuTypeof( value ) === typeName ? 1 : 0;
 	}
 	if ( typeName === 'BinaryString' ) {

package/lib/transpiler-new/codegen.js

@@ -32,6 +32,7 @@ function emitProgram( ast, options = {} ) {
 		...options,
 		asyncContext: needsAsyncWrapper && !syncEval,
 		asyncNames: new Set( collectAsyncFunctionNames( ast.body ) ),
+		evalNames: new Set( [ 'eval', ...collectEvalImportNames( ast.body ) ] ),
 		weakStorageNames: new Set( collectWeakDeclaredNames( ast.body ) ),
 		scopeNames: new Set( [
 			...expressionDeclaredNames,
@@ -91,6 +92,7 @@ function marshalCaptureNames( node, options = currentEmitContext() ) {
 		'__file__',
 		'__global__',
 		'__system__',
+		...( options.evalNames || [] ),
 	].filter( Boolean ) );
 	const localKinds = new Set( [
 		'FunctionDeclaration',
@@ -124,6 +126,21 @@ function marshalCaptureNames( node, options = currentEmitContext() ) {
 			}
 			return;
 		}
+		if ( value.type === 'TryStatement' ) {
+			visit( value.block, value );
+			for ( const handler of value.handlers || [] ) {
+				const paramName = handler.paramName;
+				const hadParam = paramName ? declared.has( paramName ) : false;
+				if ( paramName ) {
+					declared.add( paramName );
+				}
+				visit( handler.body, handler );
+				if ( paramName && !hadParam ) {
+					declared.delete( paramName );
+				}
+			}
+			return;
+		}
 		if ( value.type === 'VariableUnpackDeclaration' ) {
 			visit( value.init, value );
 			for ( const entry of bindingEntriesForPattern( value.pattern ) ) {
@@ -204,6 +221,7 @@ function nestedFunctionOptions( options = {} ) {
 		syncEval: options.syncEval,
 		asyncContext: options.asyncContext,
 		asyncNames: options.asyncNames,
+		evalNames: options.evalNames,
 		weakStorageNames: options.weakStorageNames,
 		scopeNames: options.scopeNames,
 		bodylessFunctionNames: options.bodylessFunctionNames,
@@ -898,7 +916,6 @@ function emitImportDeclaration( node, options = {} ) {
 		if (
 			node.source === 'std/eval'
 			&& importedName === 'eval'
-			&& specifier.local === 'eval'
 		) {
 			return '';
 		}
@@ -1101,6 +1118,22 @@ function collectAsyncFunctionNames( statements = [] ) {
 	return names;
 }
 
+function collectEvalImportNames( statements = [] ) {
+	const names = [];
+	for ( const stmt of statements ) {
+		if ( stmt.type !== 'ImportDeclaration' || stmt.source !== 'std/eval' ) {
+			continue;
+		}
+		for ( const specifier of stmt.specifiers || [] ) {
+			const importedName = normalizeImportedName( stmt.source, specifier.imported );
+			if ( importedName === 'eval' && specifier.local ) {
+				names.push( specifier.local );
+			}
+		}
+	}
+	return names;
+}
+
 function collectDeclaredNames( statements ) {
 	const names = [];
 	for ( const stmt of statements || [] ) {
@@ -1684,7 +1717,11 @@ function emitCallExpression( node, options = {} ) {
 		const argArray = emitCallArgumentArray( node.arguments );
 		source = `__zuzu_super_dispatch( __zuzu_super_static__, self, __zuzu_super_class__, __zuzu_super_method__, ${argArray} )`;
 	}
-	else if ( node.callee.type === 'Identifier' && node.callee.name === 'eval' && node.arguments.length > 0 ) {
+	else if (
+		node.callee.type === 'Identifier'
+		&& ( options.evalNames || new Set( [ 'eval' ] ) ).has( node.callee.name )
+		&& node.arguments.length > 0
+	) {
 		source = emitEvalCall( node.arguments );
 	}
 	else if (
@@ -1968,7 +2005,7 @@ function emitBinaryExpression( node ) {
 			return `__zuzu_ne( ${left}, ${right} )`;
 		case '!=':
 		case '≠':
-			return `__zuzu_num_ne( ${left}, ${right} )`;
+			return `__zuzu_ne( ${left}, ${right} )`;
 		case '~':
 			return `__zuzu_match( ${left}, ${right} )`;
 		case '_':

package/modules/std/io.js

@@ -389,6 +389,14 @@ class Path {
 	slurp_utf8_async() {
 		return new Task( async () => fs.promises.readFile( this.value, 'utf8' ) );
 	}
+	append( value ) {
+		traceBlockingOperation( 'std/io Path.append' );
+		if ( !( value && value.bytes instanceof Uint8Array ) ) {
+			throw new Error( `TypeException: Path.append expects BinaryString, got ${typeName( value )}` );
+		}
+		fs.appendFileSync( this.value, Buffer.from( value.bytes ) );
+		return this;
+	}
 	append_async( value ) {
 		return new Task( async () => {
 			if ( !( value && value.bytes instanceof Uint8Array ) ) {
@@ -398,6 +406,14 @@ class Path {
 			return this;
 		} );
 	}
+	append_utf8( text ) {
+		traceBlockingOperation( 'std/io Path.append_utf8' );
+		if ( typeof text !== 'string' ) {
+			throw new Error( `TypeException: Path.append_utf8 expects String, got ${typeName( text )}` );
+		}
+		fs.appendFileSync( this.value, text, 'utf8' );
+		return this;
+	}
 	append_utf8_async( text ) {
 		return new Task( async () => {
 			if ( typeof text !== 'string' ) {

package/modules/std/proc.js

@@ -2,6 +2,7 @@
 
 const { spawn, spawnSync } = require( 'node:child_process' );
 const fs = require( 'node:fs' );
+const os = require( 'node:os' );
 const path = require( 'node:path' );
 const { Task, traceBlockingOperation } = require( './task' );
 
@@ -134,12 +135,15 @@ function runCommand( cmd, options = {} ) {
 		return cwdErrorResult( cmd, options, cwd.error );
 	}
 
+	const stdinDir = fs.mkdtempSync( path.join( os.tmpdir(), 'zuzu-proc-stdin-' ) );
+	const stdinPath = path.join( stdinDir, 'stdin' );
+	fs.writeFileSync( stdinPath, stdin, 'utf8' );
+	const stdinFd = fs.openSync( stdinPath, 'r' );
 	const spawnOptions = {
-		input: stdin,
 		encoding: 'utf8',
 		maxBuffer: 10 * 1024 * 1024,
 		stdio: [
-			'pipe',
+			stdinFd,
 			captureStdout ? 'pipe' : 'ignore',
 			mergeStderr ? 'pipe' : ( captureStderr ? 'pipe' : 'ignore' ),
 		],
@@ -166,7 +170,19 @@ function runCommand( cmd, options = {} ) {
 		}
 	}
 
-	const spawned = spawnSync( cmd[0], cmd.slice( 1 ), spawnOptions );
+	let spawned;
+	try {
+		spawned = spawnSync( cmd[0], cmd.slice( 1 ), spawnOptions );
+	}
+	finally {
+		fs.closeSync( stdinFd );
+		try {
+			fs.unlinkSync( stdinPath );
+			fs.rmdirSync( stdinDir );
+		}
+		catch ( _err ) {
+		}
+	}
 	const timedOut = spawned.error && spawned.error.code === 'ETIMEDOUT';
 	const signal = timedOut
 		? 14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zuzu-js",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "JavaScript runtime, compiler, and browser bundle for ZuzuScript.",
   "main": "lib/zuzu.js",
   "bin": {