Skip to content

Implement named imports for built-in modules 'fs' and 'path' #7

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
nickna merged 1 commit into from
Jan 14, 2026
Merged

Implement named imports for built-in modules 'fs' and 'path' #7

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
162 changes: 162 additions & 0 deletions Compilation/RuntimeEmitter.FsHelpers.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -715,4 +715,166 @@ private void EmitFsAccessSync(TypeBuilder typeBuilder, EmittedRuntime runtime)
});
il.Emit(OpCodes.Ret);
}

/// <summary>
/// Emits wrapper methods for fs module functions to support named imports.
/// Each wrapper takes individual object parameters (compatible with TSFunction.Invoke).
/// </summary>
private void EmitFsModuleMethodWrappers(TypeBuilder typeBuilder, EmittedRuntime runtime)
{
// existsSync(path) -> bool
EmitFsMethodWrapperSimple(typeBuilder, runtime, "existsSync", 1,
il =>
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Call, runtime.FsExistsSync);
il.Emit(OpCodes.Box, _types.Boolean);
});

// readFileSync(path, encoding?) -> object
EmitFsMethodWrapperSimple(typeBuilder, runtime, "readFileSync", 2,
il =>
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Call, runtime.FsReadFileSync);
});

// writeFileSync(path, data) -> undefined
EmitFsMethodWrapperSimple(typeBuilder, runtime, "writeFileSync", 2,
il =>
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Call, runtime.FsWriteFileSync);
il.Emit(OpCodes.Ldnull);
});

// appendFileSync(path, data) -> undefined
EmitFsMethodWrapperSimple(typeBuilder, runtime, "appendFileSync", 2,
il =>
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Call, runtime.FsAppendFileSync);
il.Emit(OpCodes.Ldnull);
});

// unlinkSync(path) -> undefined
EmitFsMethodWrapperSimple(typeBuilder, runtime, "unlinkSync", 1,
il =>
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Call, runtime.FsUnlinkSync);
il.Emit(OpCodes.Ldnull);
});

// mkdirSync(path, options?) -> undefined
EmitFsMethodWrapperSimple(typeBuilder, runtime, "mkdirSync", 2,
il =>
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Call, runtime.FsMkdirSync);
il.Emit(OpCodes.Ldnull);
});

// rmdirSync(path, options?) -> undefined
EmitFsMethodWrapperSimple(typeBuilder, runtime, "rmdirSync", 2,
il =>
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Call, runtime.FsRmdirSync);
il.Emit(OpCodes.Ldnull);
});

// readdirSync(path) -> List<object>
EmitFsMethodWrapperSimple(typeBuilder, runtime, "readdirSync", 1,
il =>
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Call, runtime.FsReaddirSync);
});

// statSync(path) -> object
EmitFsMethodWrapperSimple(typeBuilder, runtime, "statSync", 1,
il =>
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Call, runtime.FsStatSync);
});

// lstatSync(path) -> object (same as statSync for now)
EmitFsMethodWrapperSimple(typeBuilder, runtime, "lstatSync", 1,
il =>
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Call, runtime.FsStatSync);
});

// renameSync(oldPath, newPath) -> undefined
EmitFsMethodWrapperSimple(typeBuilder, runtime, "renameSync", 2,
il =>
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Call, runtime.FsRenameSync);
il.Emit(OpCodes.Ldnull);
});

// copyFileSync(src, dest) -> undefined
EmitFsMethodWrapperSimple(typeBuilder, runtime, "copyFileSync", 2,
il =>
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Call, runtime.FsCopyFileSync);
il.Emit(OpCodes.Ldnull);
});

// accessSync(path, mode?) -> undefined
EmitFsMethodWrapperSimple(typeBuilder, runtime, "accessSync", 2,
il =>
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Call, runtime.FsAccessSync);
il.Emit(OpCodes.Ldnull);
});
}

/// <summary>
/// Emits a wrapper method for a single fs module function.
/// Takes individual object parameters (compatible with TSFunction.Invoke).
/// </summary>
private void EmitFsMethodWrapperSimple(
TypeBuilder typeBuilder,
EmittedRuntime runtime,
string methodName,
int paramCount,
Action<ILGenerator> emitCall)
{
// Create parameter types - all object
var paramTypes = new Type[paramCount];
for (int i = 0; i < paramCount; i++)
paramTypes[i] = _types.Object;

var method = typeBuilder.DefineMethod(
$"Fs_{methodName}_Wrapper",
MethodAttributes.Public | MethodAttributes.Static,
_types.Object,
paramTypes
);

var il = method.GetILGenerator();

// Emit the actual method call
emitCall(il);

il.Emit(OpCodes.Ret);

// Register the wrapper for named imports
runtime.RegisterBuiltInModuleMethod("fs", methodName, method);
}
}
Loading