AbstractModuleRecord.h [plain text]
#pragma once
#include "Identifier.h"
#include "JSDestructibleObject.h"
#include <wtf/HashMap.h>
#include <wtf/ListHashSet.h>
#include <wtf/Optional.h>
namespace JSC {
class JSModuleEnvironment;
class JSModuleNamespaceObject;
class JSMap;
class AbstractModuleRecord : public JSDestructibleObject {
friend class LLIntOffsetsExtractor;
public:
typedef JSDestructibleObject Base;
struct ExportEntry {
enum class Type {
Local,
Indirect
};
static ExportEntry createLocal(const Identifier& exportName, const Identifier& localName);
static ExportEntry createIndirect(const Identifier& exportName, const Identifier& importName, const Identifier& moduleName);
Type type;
Identifier exportName;
Identifier moduleName;
Identifier importName;
Identifier localName;
};
enum class ImportEntryType { Single, Namespace };
struct ImportEntry {
ImportEntryType type;
Identifier moduleRequest;
Identifier importName;
Identifier localName;
};
typedef WTF::ListHashSet<RefPtr<UniquedStringImpl>, IdentifierRepHash> OrderedIdentifierSet;
typedef HashMap<RefPtr<UniquedStringImpl>, ImportEntry, IdentifierRepHash, HashTraits<RefPtr<UniquedStringImpl>>> ImportEntries;
typedef HashMap<RefPtr<UniquedStringImpl>, ExportEntry, IdentifierRepHash, HashTraits<RefPtr<UniquedStringImpl>>> ExportEntries;
DECLARE_EXPORT_INFO;
void appendRequestedModule(const Identifier&);
void addStarExportEntry(const Identifier&);
void addImportEntry(const ImportEntry&);
void addExportEntry(const ExportEntry&);
std::optional<ImportEntry> tryGetImportEntry(UniquedStringImpl* localName);
std::optional<ExportEntry> tryGetExportEntry(UniquedStringImpl* exportName);
const Identifier& moduleKey() const { return m_moduleKey; }
const OrderedIdentifierSet& requestedModules() const { return m_requestedModules; }
const ExportEntries& exportEntries() const { return m_exportEntries; }
const ImportEntries& importEntries() const { return m_importEntries; }
const OrderedIdentifierSet& starExportEntries() const { return m_starExportEntries; }
void dump();
struct Resolution {
enum class Type { Resolved, NotFound, Ambiguous, Error };
static Resolution notFound();
static Resolution error();
static Resolution ambiguous();
Type type;
AbstractModuleRecord* moduleRecord;
Identifier localName;
};
Resolution resolveExport(ExecState*, const Identifier& exportName);
Resolution resolveImport(ExecState*, const Identifier& localName);
AbstractModuleRecord* hostResolveImportedModule(ExecState*, const Identifier& moduleName);
JSModuleNamespaceObject* getModuleNamespace(ExecState*);
JSModuleEnvironment* moduleEnvironment()
{
ASSERT(m_moduleEnvironment);
return m_moduleEnvironment.get();
}
JSModuleEnvironment* moduleEnvironmentMayBeNull()
{
return m_moduleEnvironment.get();
}
void link(ExecState*, JSValue scriptFetcher);
JS_EXPORT_PRIVATE JSValue evaluate(ExecState*);
protected:
AbstractModuleRecord(VM&, Structure*, const Identifier&);
void finishCreation(ExecState*, VM&);
static void visitChildren(JSCell*, SlotVisitor&);
static void destroy(JSCell*);
WriteBarrier<JSModuleEnvironment> m_moduleEnvironment;
private:
struct ResolveQuery;
static Resolution resolveExportImpl(ExecState*, const ResolveQuery&);
std::optional<Resolution> tryGetCachedResolution(UniquedStringImpl* exportName);
void cacheResolution(UniquedStringImpl* exportName, const Resolution&);
Identifier m_moduleKey;
ImportEntries m_importEntries;
ExportEntries m_exportEntries;
OrderedIdentifierSet m_starExportEntries;
OrderedIdentifierSet m_requestedModules;
WriteBarrier<JSMap> m_dependenciesMap;
WriteBarrier<JSModuleNamespaceObject> m_moduleNamespaceObject;
typedef HashMap<RefPtr<UniquedStringImpl>, Resolution, IdentifierRepHash, HashTraits<RefPtr<UniquedStringImpl>>> Resolutions;
Resolutions m_resolutionCache;
};
}