mirrors/bun.sh
1
0
Fork 0
mirror of https://github.com/oven-sh/bun synced 2026-02-09 10:28:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rewrite built-in modules to use CommonJS over ESM (#3814)

Browse Source 
* stfdsafsd

sadffdsa

stuff

finish commonjs stuff

asdf

not done but work

not done but work

not done yet but this is how far i am

remove files

lol

update built files

uncomment everything in events lol

export default

stuff

* afdsafsd

* its not perfect but almost done

* okay

* cool

* remove temp file

* finish rebase

* revert settings.json

* a

* ch-ch-ch-ch-changes

* okay

* remove this check in release for now

* sxdcfghnjm,

* lkjhgf

* fmt

* filename can be null

* Update NodeModuleModule.h

* weee

* fmt

---------

Co-authored-by: Jarred Sumner <709451+Jarred-Sumner@users.noreply.github.com>
This commit is contained in:
dave caruso
2023-08-02 16:27:36 -07:00
committed by GitHub
parent 7656b4b17e
commit c2a77cf7ec
199 changed files with 11153 additions and 31396 deletions
Download Patch File Download Diff File Expand all files Collapse all files

220
src/bun.js/bindings/ModuleLoader.cpp
View File

@@ -27,15 +27,6 @@
#include "EventEmitter.h"
#include "JSEventEmitter.h"
#include "../modules/BufferModule.h"
#include "../modules/EventsModule.h"
#include "../modules/ProcessModule.h"
#include "../modules/StringDecoderModule.h"
#include "../modules/ObjectModule.h"
#include "../modules/NodeModuleModule.h"
#include "../modules/TTYModule.h"
#include "../modules/ConstantsModule.h"
#include "node_util_types.h"
#include "CommonJSModuleRecord.h"
#include <JavaScriptCore/JSModuleLoader.h>
#include <JavaScriptCore/Completion.h>
@@ -43,7 +34,13 @@
#include <JavaScriptCore/JSMap.h>
#include <JavaScriptCore/JSMapInlines.h>
#include "../modules/_NativeModule.h"
#include "../../js/out/NativeModuleImpl.h"
#include "../modules/ObjectModule.h"
namespace Bun {
using namespace JSC;
using namespace Zig;
using namespace WebCore;
@@ -67,7 +64,38 @@ static JSC::JSInternalPromise* resolvedInternalPromise(JSC::JSGlobalObject* glob
return promise;
}
using namespace JSC;
// Converts an object from InternalModuleRegistry into { ...obj, default: obj }
JSC::SyntheticSourceProvider::SyntheticSourceGenerator
generateInternalModuleSourceCode(JSC::JSGlobalObject* globalObject, JSC::JSObject* object)
{
return [object](JSC::JSGlobalObject* lexicalGlobalObject,
JSC::Identifier moduleKey,
Vector<JSC::Identifier, 4>& exportNames,
JSC::MarkedArgumentBuffer& exportValues) -> void {
JSC::VM& vm = lexicalGlobalObject->vm();
GlobalObject* globalObject = reinterpret_cast<GlobalObject*>(lexicalGlobalObject);
JSC::EnsureStillAliveScope stillAlive(object);
auto throwScope = DECLARE_THROW_SCOPE(vm);
PropertyNameArray properties(vm, PropertyNameMode::Strings, PrivateSymbolMode::Exclude);
object->getPropertyNames(globalObject, properties, DontEnumPropertiesMode::Exclude);
RETURN_IF_EXCEPTION(throwScope, {});
auto len = properties.size() + 1;
exportNames.reserveCapacity(len);
exportValues.ensureCapacity(len);
exportNames.append(vm.propertyNames->defaultKeyword);
exportValues.append(object);
for (auto& entry : properties) {
exportNames.append(entry);
exportValues.append(object->get(globalObject, entry));
}
};
}
static OnLoadResult handleOnLoadObjectResult(Zig::GlobalObject* globalObject, JSC::JSObject* object)
{
@@ -389,45 +417,35 @@ JSValue fetchCommonJSModule(
return JSValue();
}
switch (res->result.value.tag) {
case SyntheticModuleType::Module: {
target->evaluate(globalObject, Bun::toWTFString(*specifier), generateNodeModuleModule);
RETURN_IF_EXCEPTION(scope, {});
RELEASE_AND_RETURN(scope, target);
auto tag = res->result.value.tag;
switch (tag) {
// Generated native module cases
#define CASE(str, name) \
case SyntheticModuleType::name: { \
target->evaluate(globalObject, Bun::toWTFString(*specifier), generateNativeModule_##name); \
RETURN_IF_EXCEPTION(scope, {}); \
RELEASE_AND_RETURN(scope, target); \
}
BUN_FOREACH_NATIVE_MODULE(CASE)
#undef CASE
case SyntheticModuleType::ESM: {
RELEASE_AND_RETURN(scope, jsNumber(-1));
}
case SyntheticModuleType::Buffer: {
target->evaluate(globalObject, Bun::toWTFString(*specifier), generateBufferSourceCode);
RETURN_IF_EXCEPTION(scope, {});
RELEASE_AND_RETURN(scope, target);
}
case SyntheticModuleType::TTY: {
target->evaluate(globalObject, Bun::toWTFString(*specifier), generateTTYSourceCode);
RETURN_IF_EXCEPTION(scope, {});
RELEASE_AND_RETURN(scope, target);
}
case SyntheticModuleType::NodeUtilTypes: {
target->evaluate(globalObject, Bun::toWTFString(*specifier), Bun::generateNodeUtilTypesSourceCode);
RETURN_IF_EXCEPTION(scope, {});
RELEASE_AND_RETURN(scope, target);
}
case SyntheticModuleType::Process: {
target->evaluate(globalObject, Bun::toWTFString(*specifier), generateProcessSourceCode);
RETURN_IF_EXCEPTION(scope, {});
RELEASE_AND_RETURN(scope, target);
}
case SyntheticModuleType::Events: {
target->evaluate(globalObject, Bun::toWTFString(*specifier), generateEventsSourceCode);
RETURN_IF_EXCEPTION(scope, {});
RELEASE_AND_RETURN(scope, target);
}
case SyntheticModuleType::StringDecoder: {
target->evaluate(globalObject, Bun::toWTFString(*specifier), generateStringDecoderSourceCode);
RETURN_IF_EXCEPTION(scope, {});
RELEASE_AND_RETURN(scope, target);
}
default: {
RELEASE_AND_RETURN(scope, jsNumber(-1));
if (tag & SyntheticModuleType::InternalModuleRegistryFlag) {
constexpr auto mask = (SyntheticModuleType::InternalModuleRegistryFlag - 1);
target->putDirect(
vm,
builtinNames.exportsPublicName(),
globalObject->internalModuleRegistry()->requireId(globalObject, vm, static_cast<InternalModuleRegistry::Field>(tag & mask)),
JSC::PropertyAttribute::ReadOnly | 0);
RETURN_IF_EXCEPTION(scope, {});
RELEASE_AND_RETURN(scope, target);
} else {
RELEASE_AND_RETURN(scope, jsNumber(-1));
}
}
}
}
@@ -496,7 +514,7 @@ JSValue fetchCommonJSModule(
}
template<bool allowPromise>
static JSValue fetchSourceCode(
static JSValue fetchESMSourceCode(
Zig::GlobalObject* globalObject,
ErrorableResolvedSource* res,
BunString* specifier,
@@ -555,67 +573,32 @@ static JSValue fetchSourceCode(
auto moduleKey = Bun::toWTFString(*specifier);
switch (res->result.value.tag) {
case SyntheticModuleType::Module: {
auto source = JSC::SourceCode(
JSC::SyntheticSourceProvider::create(generateNodeModuleModule,
JSC::SourceOrigin(), WTFMove(moduleKey)));
return rejectOrResolve(JSSourceCode::create(vm, WTFMove(source)));
}
case SyntheticModuleType::Buffer: {
auto source = JSC::SourceCode(
JSC::SyntheticSourceProvider::create(generateBufferSourceCode,
JSC::SourceOrigin(), WTFMove(moduleKey)));
return rejectOrResolve(JSSourceCode::create(vm, WTFMove(source)));
}
case SyntheticModuleType::TTY: {
auto source = JSC::SourceCode(
JSC::SyntheticSourceProvider::create(generateTTYSourceCode,
JSC::SourceOrigin(), WTFMove(moduleKey)));
return rejectOrResolve(JSSourceCode::create(vm, WTFMove(source)));
}
case SyntheticModuleType::NodeUtilTypes: {
auto source = JSC::SourceCode(
JSC::SyntheticSourceProvider::create(Bun::generateNodeUtilTypesSourceCode,
JSC::SourceOrigin(), WTFMove(moduleKey)));
return rejectOrResolve(JSSourceCode::create(vm, WTFMove(source)));
}
case SyntheticModuleType::Process: {
auto source = JSC::SourceCode(
JSC::SyntheticSourceProvider::create(generateProcessSourceCode,
JSC::SourceOrigin(), WTFMove(moduleKey)));
return rejectOrResolve(JSSourceCode::create(vm, WTFMove(source)));
}
case SyntheticModuleType::Events: {
auto source = JSC::SourceCode(
JSC::SyntheticSourceProvider::create(generateEventsSourceCode,
JSC::SourceOrigin(), WTFMove(moduleKey)));
return rejectOrResolve(JSSourceCode::create(vm, WTFMove(source)));
}
case SyntheticModuleType::StringDecoder: {
auto source = JSC::SourceCode(
JSC::SyntheticSourceProvider::create(generateStringDecoderSourceCode,
JSC::SourceOrigin(), WTFMove(moduleKey)));
return rejectOrResolve(JSSourceCode::create(vm, WTFMove(source)));
}
case SyntheticModuleType::Constants: {
auto source = JSC::SourceCode(
JSC::SyntheticSourceProvider::create(generateConstantsSourceCode,
JSC::SourceOrigin(), WTFMove(moduleKey)));
return rejectOrResolve(JSSourceCode::create(vm, WTFMove(source)));
}
default: {
auto tag = res->result.value.tag;
switch (tag) {
case SyntheticModuleType::ESM: {
auto&& provider = Zig::SourceProvider::create(globalObject, res->result.value, JSC::SourceProviderSourceType::Module, true);
return rejectOrResolve(JSC::JSSourceCode::create(vm, JSC::SourceCode(provider)));
return rejectOrResolve(JSSourceCode::create(vm, JSC::SourceCode(provider)));
}
#define CASE(str, name) \
case (SyntheticModuleType::name): { \
auto source = JSC::SourceCode(JSC::SyntheticSourceProvider::create(generateNativeModule_##name, JSC::SourceOrigin(), WTFMove(moduleKey))); \
return rejectOrResolve(JSSourceCode::create(vm, WTFMove(source))); \
}
BUN_FOREACH_NATIVE_MODULE(CASE)
#undef CASE
// CommonJS modules from src/js/*
default: {
if (tag & SyntheticModuleType::InternalModuleRegistryFlag) {
constexpr auto mask = (SyntheticModuleType::InternalModuleRegistryFlag - 1);
auto* internalModule = jsCast<JSObject*>(globalObject->internalModuleRegistry()->requireId(globalObject, vm, static_cast<InternalModuleRegistry::Field>(tag & mask)));
auto source = JSC::SourceCode(JSC::SyntheticSourceProvider::create(generateInternalModuleSourceCode(globalObject, internalModule), JSC::SourceOrigin(), WTFMove(moduleKey)));
return rejectOrResolve(JSSourceCode::create(vm, WTFMove(source)));
} else {
auto&& provider = Zig::SourceProvider::create(globalObject, res->result.value, JSC::SourceProviderSourceType::Module, true);
return rejectOrResolve(JSC::JSSourceCode::create(vm, JSC::SourceCode(provider)));
}
}
}
}
@@ -715,36 +698,21 @@ extern "C" JSC::EncodedJSValue jsFunctionOnLoadObjectResultReject(JSC::JSGlobalO
return JSValue::encode(reason);
}
JSValue fetchSourceCodeSync(
JSValue fetchESMSourceCodeSync(
Zig::GlobalObject* globalObject,
ErrorableResolvedSource* res,
BunString* specifier,
BunString* referrer)
{
return fetchSourceCode<false>(globalObject, res, specifier, referrer);
return fetchESMSourceCode<false>(globalObject, res, specifier, referrer);
}
JSValue fetchSourceCodeAsync(
JSValue fetchESMSourceCodeAsync(
Zig::GlobalObject* globalObject,
ErrorableResolvedSource* res,
BunString* specifier,
BunString* referrer)
{
return fetchSourceCode<true>(globalObject, res, specifier, referrer);
return fetchESMSourceCode<true>(globalObject, res, specifier, referrer);
}
}
namespace JSC {
template<unsigned passedNumberOfInternalFields>
template<typename Visitor>
void JSInternalFieldObjectImpl<passedNumberOfInternalFields>::visitChildrenImpl(JSCell* cell, Visitor& visitor)
{
auto* thisObject = jsCast<JSInternalFieldObjectImpl*>(cell);
ASSERT_GC_OBJECT_INHERITS(thisObject, info());
Base::visitChildren(thisObject, visitor);
visitor.appendValues(thisObject->m_internalFields, numberOfInternalFields);
}
DEFINE_VISIT_CHILDREN_WITH_MODIFIER(template<unsigned passedNumberOfInternalFields>, JSInternalFieldObjectImpl<passedNumberOfInternalFields>);
} // namespace JSC