378 lines
13 KiB
C++
378 lines
13 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
* vim: set ts=8 sts=4 et sw=4 tw=99:
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#ifndef builtin_ModuleObject_h
|
|
#define builtin_ModuleObject_h
|
|
|
|
#include "jsapi.h"
|
|
#include "jsatom.h"
|
|
|
|
#include "builtin/SelfHostingDefines.h"
|
|
#include "gc/Zone.h"
|
|
#include "js/GCVector.h"
|
|
#include "js/Id.h"
|
|
#include "vm/NativeObject.h"
|
|
#include "vm/ProxyObject.h"
|
|
|
|
namespace js {
|
|
|
|
class ModuleEnvironmentObject;
|
|
class ModuleObject;
|
|
|
|
namespace frontend {
|
|
class ParseNode;
|
|
class TokenStream;
|
|
} /* namespace frontend */
|
|
|
|
typedef Rooted<ModuleObject*> RootedModuleObject;
|
|
typedef Handle<ModuleObject*> HandleModuleObject;
|
|
typedef Rooted<ModuleEnvironmentObject*> RootedModuleEnvironmentObject;
|
|
typedef Handle<ModuleEnvironmentObject*> HandleModuleEnvironmentObject;
|
|
|
|
class ImportEntryObject : public NativeObject
|
|
{
|
|
public:
|
|
enum
|
|
{
|
|
ModuleRequestSlot = 0,
|
|
ImportNameSlot,
|
|
LocalNameSlot,
|
|
LineNumberSlot,
|
|
ColumnNumberSlot,
|
|
SlotCount
|
|
};
|
|
|
|
static const Class class_;
|
|
static JSObject* initClass(ExclusiveContext* cx, HandleObject obj);
|
|
static bool isInstance(HandleValue value);
|
|
static ImportEntryObject* create(ExclusiveContext* cx,
|
|
HandleAtom moduleRequest,
|
|
HandleAtom importName,
|
|
HandleAtom localName,
|
|
uint32_t lineNumber,
|
|
uint32_t columnNumber);
|
|
JSAtom* moduleRequest() const;
|
|
JSAtom* importName() const;
|
|
JSAtom* localName() const;
|
|
uint32_t lineNumber() const;
|
|
uint32_t columnNumber() const;
|
|
};
|
|
|
|
typedef Rooted<ImportEntryObject*> RootedImportEntryObject;
|
|
typedef Handle<ImportEntryObject*> HandleImportEntryObject;
|
|
|
|
class ExportEntryObject : public NativeObject
|
|
{
|
|
public:
|
|
enum
|
|
{
|
|
ExportNameSlot = 0,
|
|
ModuleRequestSlot,
|
|
ImportNameSlot,
|
|
LocalNameSlot,
|
|
LineNumberSlot,
|
|
ColumnNumberSlot,
|
|
SlotCount
|
|
};
|
|
|
|
static const Class class_;
|
|
static JSObject* initClass(ExclusiveContext* cx, HandleObject obj);
|
|
static bool isInstance(HandleValue value);
|
|
static ExportEntryObject* create(ExclusiveContext* cx,
|
|
HandleAtom maybeExportName,
|
|
HandleAtom maybeModuleRequest,
|
|
HandleAtom maybeImportName,
|
|
HandleAtom maybeLocalName,
|
|
uint32_t lineNumber,
|
|
uint32_t columnNumber);
|
|
JSAtom* exportName() const;
|
|
JSAtom* moduleRequest() const;
|
|
JSAtom* importName() const;
|
|
JSAtom* localName() const;
|
|
uint32_t lineNumber() const;
|
|
uint32_t columnNumber() const;
|
|
};
|
|
|
|
typedef Rooted<ExportEntryObject*> RootedExportEntryObject;
|
|
typedef Handle<ExportEntryObject*> HandleExportEntryObject;
|
|
|
|
class IndirectBindingMap
|
|
{
|
|
public:
|
|
explicit IndirectBindingMap(Zone* zone);
|
|
bool init();
|
|
|
|
void trace(JSTracer* trc);
|
|
|
|
bool putNew(JSContext* cx, HandleId name,
|
|
HandleModuleEnvironmentObject environment, HandleId localName);
|
|
|
|
size_t count() const {
|
|
return map_.count();
|
|
}
|
|
|
|
bool has(jsid name) const {
|
|
return map_.has(name);
|
|
}
|
|
|
|
bool lookup(jsid name, ModuleEnvironmentObject** envOut, Shape** shapeOut) const;
|
|
|
|
template <typename Func>
|
|
void forEachExportedName(Func func) const {
|
|
for (auto r = map_.all(); !r.empty(); r.popFront())
|
|
func(r.front().key());
|
|
}
|
|
|
|
private:
|
|
struct Binding
|
|
{
|
|
Binding(ModuleEnvironmentObject* environment, Shape* shape);
|
|
HeapPtr<ModuleEnvironmentObject*> environment;
|
|
HeapPtr<Shape*> shape;
|
|
};
|
|
|
|
typedef HashMap<jsid, Binding, DefaultHasher<jsid>, ZoneAllocPolicy> Map;
|
|
|
|
Map map_;
|
|
};
|
|
|
|
class ModuleNamespaceObject : public ProxyObject
|
|
{
|
|
public:
|
|
static bool isInstance(HandleValue value);
|
|
static ModuleNamespaceObject* create(JSContext* cx, HandleModuleObject module);
|
|
|
|
ModuleObject& module();
|
|
JSObject& exports();
|
|
IndirectBindingMap& bindings();
|
|
|
|
bool addBinding(JSContext* cx, HandleAtom exportedName, HandleModuleObject targetModule,
|
|
HandleAtom localName);
|
|
|
|
private:
|
|
struct ProxyHandler : public BaseProxyHandler
|
|
{
|
|
ProxyHandler();
|
|
|
|
bool getOwnPropertyDescriptor(JSContext* cx, HandleObject proxy, HandleId id,
|
|
MutableHandle<PropertyDescriptor> desc) const override;
|
|
bool defineProperty(JSContext* cx, HandleObject proxy, HandleId id,
|
|
Handle<PropertyDescriptor> desc,
|
|
ObjectOpResult& result) const override;
|
|
bool ownPropertyKeys(JSContext* cx, HandleObject proxy,
|
|
AutoIdVector& props) const override;
|
|
bool delete_(JSContext* cx, HandleObject proxy, HandleId id,
|
|
ObjectOpResult& result) const override;
|
|
bool getPrototype(JSContext* cx, HandleObject proxy,
|
|
MutableHandleObject protop) const override;
|
|
bool setPrototype(JSContext* cx, HandleObject proxy, HandleObject proto,
|
|
ObjectOpResult& result) const override;
|
|
bool getPrototypeIfOrdinary(JSContext* cx, HandleObject proxy, bool* isOrdinary,
|
|
MutableHandleObject protop) const override;
|
|
bool setImmutablePrototype(JSContext* cx, HandleObject proxy,
|
|
bool* succeeded) const override;
|
|
|
|
bool preventExtensions(JSContext* cx, HandleObject proxy,
|
|
ObjectOpResult& result) const override;
|
|
bool isExtensible(JSContext* cx, HandleObject proxy, bool* extensible) const override;
|
|
bool has(JSContext* cx, HandleObject proxy, HandleId id, bool* bp) const override;
|
|
bool get(JSContext* cx, HandleObject proxy, HandleValue receiver,
|
|
HandleId id, MutableHandleValue vp) const override;
|
|
bool set(JSContext* cx, HandleObject proxy, HandleId id, HandleValue v,
|
|
HandleValue receiver, ObjectOpResult& result) const override;
|
|
|
|
static const char family;
|
|
};
|
|
|
|
public:
|
|
static const ProxyHandler proxyHandler;
|
|
};
|
|
|
|
typedef Rooted<ModuleNamespaceObject*> RootedModuleNamespaceObject;
|
|
typedef Handle<ModuleNamespaceObject*> HandleModuleNamespaceObject;
|
|
|
|
struct FunctionDeclaration
|
|
{
|
|
FunctionDeclaration(HandleAtom name, HandleFunction fun);
|
|
void trace(JSTracer* trc);
|
|
|
|
HeapPtr<JSAtom*> name;
|
|
HeapPtr<JSFunction*> fun;
|
|
};
|
|
|
|
using FunctionDeclarationVector = GCVector<FunctionDeclaration, 0, ZoneAllocPolicy>;
|
|
|
|
// Possible values for ModuleStatus are defined in SelfHostingDefines.h.
|
|
using ModuleStatus = int32_t;
|
|
|
|
class ModuleObject : public NativeObject
|
|
{
|
|
public:
|
|
enum
|
|
{
|
|
ScriptSlot = 0,
|
|
InitialEnvironmentSlot,
|
|
EnvironmentSlot,
|
|
NamespaceSlot,
|
|
StatusSlot,
|
|
ErrorSlot,
|
|
HostDefinedSlot,
|
|
RequestedModulesSlot,
|
|
ImportEntriesSlot,
|
|
LocalExportEntriesSlot,
|
|
IndirectExportEntriesSlot,
|
|
StarExportEntriesSlot,
|
|
ImportBindingsSlot,
|
|
NamespaceExportsSlot,
|
|
NamespaceBindingsSlot,
|
|
FunctionDeclarationsSlot,
|
|
DFSIndexSlot,
|
|
DFSAncestorIndexSlot,
|
|
SlotCount
|
|
};
|
|
|
|
static_assert(EnvironmentSlot == MODULE_OBJECT_ENVIRONMENT_SLOT,
|
|
"EnvironmentSlot must match self-hosting define");
|
|
static_assert(StatusSlot == MODULE_OBJECT_STATUS_SLOT,
|
|
"StatusSlot must match self-hosting define");
|
|
static_assert(ErrorSlot == MODULE_OBJECT_ERROR_SLOT,
|
|
"ErrorSlot must match self-hosting define");
|
|
static_assert(DFSIndexSlot == MODULE_OBJECT_DFS_INDEX_SLOT,
|
|
"DFSIndexSlot must match self-hosting define");
|
|
static_assert(DFSAncestorIndexSlot == MODULE_OBJECT_DFS_ANCESTOR_INDEX_SLOT,
|
|
"DFSAncestorIndexSlot must match self-hosting define");
|
|
|
|
static const Class class_;
|
|
|
|
static bool isInstance(HandleValue value);
|
|
|
|
static ModuleObject* create(ExclusiveContext* cx);
|
|
void init(HandleScript script);
|
|
void setInitialEnvironment(Handle<ModuleEnvironmentObject*> initialEnvironment);
|
|
void initImportExportData(HandleArrayObject requestedModules,
|
|
HandleArrayObject importEntries,
|
|
HandleArrayObject localExportEntries,
|
|
HandleArrayObject indiretExportEntries,
|
|
HandleArrayObject starExportEntries);
|
|
static bool Freeze(JSContext* cx, HandleModuleObject self);
|
|
#ifdef DEBUG
|
|
static bool IsFrozen(JSContext* cx, HandleModuleObject self);
|
|
#endif
|
|
void fixEnvironmentsAfterCompartmentMerge();
|
|
|
|
JSScript* script() const;
|
|
Scope* enclosingScope() const;
|
|
ModuleEnvironmentObject& initialEnvironment() const;
|
|
ModuleEnvironmentObject* environment() const;
|
|
ModuleNamespaceObject* namespace_();
|
|
ModuleStatus status() const;
|
|
Value error() const;
|
|
Value hostDefinedField() const;
|
|
ArrayObject& requestedModules() const;
|
|
ArrayObject& importEntries() const;
|
|
ArrayObject& localExportEntries() const;
|
|
ArrayObject& indirectExportEntries() const;
|
|
ArrayObject& starExportEntries() const;
|
|
IndirectBindingMap& importBindings();
|
|
JSObject* namespaceExports();
|
|
IndirectBindingMap* namespaceBindings();
|
|
|
|
static bool Instantiate(JSContext* cx, HandleModuleObject self);
|
|
static bool Evaluate(JSContext* cx, HandleModuleObject self);
|
|
|
|
void setHostDefinedField(const JS::Value& value);
|
|
|
|
// For intrinsic_CreateModuleEnvironment.
|
|
void createEnvironment();
|
|
|
|
// For BytecodeEmitter.
|
|
bool noteFunctionDeclaration(ExclusiveContext* cx, HandleAtom name, HandleFunction fun);
|
|
|
|
// For intrinsic_InstantiateModuleFunctionDeclarations.
|
|
static bool instantiateFunctionDeclarations(JSContext* cx, HandleModuleObject self);
|
|
|
|
// For intrinsic_ExecuteModule.
|
|
static bool execute(JSContext* cx, HandleModuleObject self, MutableHandleValue rval);
|
|
|
|
// For intrinsic_NewModuleNamespace.
|
|
static ModuleNamespaceObject* createNamespace(JSContext* cx, HandleModuleObject self,
|
|
HandleObject exports);
|
|
|
|
private:
|
|
static const ClassOps classOps_;
|
|
|
|
static void trace(JSTracer* trc, JSObject* obj);
|
|
static void finalize(js::FreeOp* fop, JSObject* obj);
|
|
|
|
bool hasScript() const;
|
|
bool hasImportBindings() const;
|
|
FunctionDeclarationVector* functionDeclarations();
|
|
};
|
|
|
|
// Process a module's parse tree to collate the import and export data used when
|
|
// creating a ModuleObject.
|
|
class MOZ_STACK_CLASS ModuleBuilder
|
|
{
|
|
public:
|
|
explicit ModuleBuilder(ExclusiveContext* cx, HandleModuleObject module,
|
|
const frontend::TokenStream& tokenStream);
|
|
|
|
bool processImport(frontend::ParseNode* pn);
|
|
bool processExport(frontend::ParseNode* pn);
|
|
bool processExportFrom(frontend::ParseNode* pn);
|
|
|
|
bool hasExportedName(JSAtom* name) const;
|
|
|
|
using ExportEntryVector = GCVector<ExportEntryObject*>;
|
|
const ExportEntryVector& localExportEntries() const {
|
|
return localExportEntries_;
|
|
}
|
|
|
|
bool buildTables();
|
|
bool initModule();
|
|
|
|
private:
|
|
using AtomVector = GCVector<JSAtom*>;
|
|
using RootedAtomVector = JS::Rooted<AtomVector>;
|
|
using ImportEntryVector = GCVector<ImportEntryObject*>;
|
|
using RootedImportEntryVector = JS::Rooted<ImportEntryVector>;
|
|
using RootedExportEntryVector = JS::Rooted<ExportEntryVector>;
|
|
|
|
ExclusiveContext* cx_;
|
|
RootedModuleObject module_;
|
|
const frontend::TokenStream& tokenStream_;
|
|
RootedAtomVector requestedModules_;
|
|
RootedAtomVector importedBoundNames_;
|
|
RootedImportEntryVector importEntries_;
|
|
RootedExportEntryVector exportEntries_;
|
|
RootedExportEntryVector localExportEntries_;
|
|
RootedExportEntryVector indirectExportEntries_;
|
|
RootedExportEntryVector starExportEntries_;
|
|
|
|
ImportEntryObject* importEntryFor(JSAtom* localName) const;
|
|
|
|
bool appendExportEntry(HandleAtom exportName, HandleAtom localName,
|
|
frontend::ParseNode* node = nullptr);
|
|
bool appendExportFromEntry(HandleAtom exportName, HandleAtom moduleRequest,
|
|
HandleAtom importName, frontend::ParseNode* node);
|
|
|
|
bool maybeAppendRequestedModule(HandleAtom module);
|
|
|
|
template <typename T>
|
|
ArrayObject* createArray(const GCVector<T>& vector);
|
|
};
|
|
|
|
} // namespace js
|
|
|
|
template<>
|
|
inline bool
|
|
JSObject::is<js::ModuleNamespaceObject>() const
|
|
{
|
|
return js::IsDerivedProxyObject(this, &js::ModuleNamespaceObject::proxyHandler);
|
|
}
|
|
|
|
#endif /* builtin_ModuleObject_h */
|