blob: f156d7a411ac79409e13695ea78ee1fe7b8a98a1 [file] [log] [blame]
// Copyright 2012 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_AST_MODULES_H_
#define V8_AST_MODULES_H_
#include "src/parsing/scanner.h" // Only for Scanner::Location.
#include "src/zone/zone-containers.h"
namespace v8 {
namespace internal {
class AstRawString;
class ModuleRequest;
class SourceTextModuleInfo;
class SourceTextModuleInfoEntry;
class PendingCompilationErrorHandler;
class SourceTextModuleDescriptor : public ZoneObject {
explicit SourceTextModuleDescriptor(Zone* zone)
: module_requests_(zone),
regular_imports_(zone) {}
using ImportAssertions =
ZoneMap<const AstRawString*,
std::pair<const AstRawString*, Scanner::Location>>;
// The following Add* methods are high-level convenience functions for use by
// the parser.
// import x from "foo.js";
// import {x} from "foo.js";
// import {x as y} from "foo.js";
void AddImport(const AstRawString* import_name,
const AstRawString* local_name,
const AstRawString* module_request,
const ImportAssertions* import_assertions,
const Scanner::Location loc,
const Scanner::Location specifier_loc, Zone* zone);
// import * as x from "foo.js";
void AddStarImport(const AstRawString* local_name,
const AstRawString* module_request,
const ImportAssertions* import_assertions,
const Scanner::Location loc,
const Scanner::Location specifier_loc, Zone* zone);
// import "foo.js";
// import {} from "foo.js";
// export {} from "foo.js"; (sic!)
void AddEmptyImport(const AstRawString* module_request,
const ImportAssertions* import_assertions,
const Scanner::Location specifier_loc, Zone* zone);
// export {x};
// export {x as y};
// export VariableStatement
// export Declaration
// export default ...
void AddExport(
const AstRawString* local_name, const AstRawString* export_name,
const Scanner::Location loc, Zone* zone);
// export {x} from "foo.js";
// export {x as y} from "foo.js";
void AddExport(const AstRawString* export_name,
const AstRawString* import_name,
const AstRawString* module_request,
const ImportAssertions* import_assertions,
const Scanner::Location loc,
const Scanner::Location specifier_loc, Zone* zone);
// export * from "foo.js";
void AddStarExport(const AstRawString* module_request,
const ImportAssertions* import_assertions,
const Scanner::Location loc,
const Scanner::Location specifier_loc, Zone* zone);
// Check if module is well-formed and report error if not.
// Also canonicalize indirect exports.
bool Validate(ModuleScope* module_scope,
PendingCompilationErrorHandler* error_handler, Zone* zone);
struct Entry : public ZoneObject {
Scanner::Location location;
const AstRawString* export_name;
const AstRawString* local_name;
const AstRawString* import_name;
// The module_request value records the order in which modules are
// requested. It also functions as an index into the SourceTextModuleInfo's
// array of module specifiers and into the Module's array of requested
// modules. A negative value means no module request.
int module_request;
// Import/export entries that are associated with a MODULE-allocated
// variable (i.e. regular_imports and regular_exports after Validate) use
// the cell_index value to encode the location of their cell. During
// variable allocation, this will be be copied into the variable's index
// field.
// Entries that are not associated with a MODULE-allocated variable have
// GetCellIndexKind(cell_index) == kInvalid.
int cell_index;
// TODO(neis): Remove local_name component?
explicit Entry(Scanner::Location loc)
: location(loc),
cell_index(0) {}
template <typename LocalIsolate>
Handle<SourceTextModuleInfoEntry> Serialize(LocalIsolate* isolate) const;
enum CellIndexKind { kInvalid, kExport, kImport };
static CellIndexKind GetCellIndexKind(int cell_index);
class AstModuleRequest : public ZoneObject {
// TODO(v8:10958): Consider storing module request location here
// instead of using separate ModuleRequestLocation struct.
AstModuleRequest(const AstRawString* specifier,
const ImportAssertions* import_assertions)
: specifier_(specifier), import_assertions_(import_assertions) {}
template <typename LocalIsolate>
Handle<v8::internal::ModuleRequest> Serialize(LocalIsolate* isolate) const;
const AstRawString* specifier() const { return specifier_; }
const ImportAssertions* import_assertions() const {
return import_assertions_;
const AstRawString* specifier_;
const ImportAssertions* import_assertions_;
struct ModuleRequestLocation {
// The index at which we will place the request in SourceTextModuleInfo's
// module_requests FixedArray.
int index;
// The JS source code position of the request, used for reporting errors.
int position;
ModuleRequestLocation(int index, int position)
: index(index), position(position) {}
// Custom content-based comparer for the below maps, to keep them stable
// across parses.
struct V8_EXPORT_PRIVATE AstRawStringComparer {
bool operator()(const AstRawString* lhs, const AstRawString* rhs) const;
static int ThreeWayCompare(const AstRawString* lhs,
const AstRawString* rhs);
struct V8_EXPORT_PRIVATE ModuleRequestComparer {
bool operator()(const AstModuleRequest* lhs,
const AstModuleRequest* rhs) const;
using ModuleRequestMap =
ZoneMap<const AstModuleRequest*, ModuleRequestLocation,
using RegularExportMap =
ZoneMultimap<const AstRawString*, Entry*, AstRawStringComparer>;
using RegularImportMap =
ZoneMap<const AstRawString*, Entry*, AstRawStringComparer>;
// Module requests.
const ModuleRequestMap& module_requests() const { return module_requests_; }
// Namespace imports.
const ZoneVector<const Entry*>& namespace_imports() const {
return namespace_imports_;
// All the remaining imports, indexed by local name.
const RegularImportMap& regular_imports() const { return regular_imports_; }
// Star exports and explicitly indirect exports.
const ZoneVector<const Entry*>& special_exports() const {
return special_exports_;
// All the remaining exports, indexed by local name.
// After canonicalization (see Validate), these are exactly the local exports.
const RegularExportMap& regular_exports() const { return regular_exports_; }
void AddRegularExport(Entry* entry) {
DCHECK_LT(entry->module_request, 0);
regular_exports_.insert(std::make_pair(entry->local_name, entry));
void AddSpecialExport(const Entry* entry, Zone* zone) {
DCHECK_LE(0, entry->module_request);
void AddRegularImport(Entry* entry) {
DCHECK_LE(0, entry->module_request);
regular_imports_.insert(std::make_pair(entry->local_name, entry));
// We don't care if there's already an entry for this local name, as in that
// case we will report an error when declaring the variable.
void AddNamespaceImport(const Entry* entry, Zone* zone) {
DCHECK_LE(0, entry->module_request);
template <typename LocalIsolate>
Handle<FixedArray> SerializeRegularExports(LocalIsolate* isolate,
Zone* zone) const;
ModuleRequestMap module_requests_;
ZoneVector<const Entry*> special_exports_;
ZoneVector<const Entry*> namespace_imports_;
RegularExportMap regular_exports_;
RegularImportMap regular_imports_;
// If there are multiple export entries with the same export name, return the
// last of them (in source order). Otherwise return nullptr.
const Entry* FindDuplicateExport(Zone* zone) const;
// Find any implicitly indirect exports and make them explicit.
// An explicitly indirect export is an export entry arising from an export
// statement of the following form:
// export {a as c} from "X";
// An implicitly indirect export corresponds to
// export {b as c};
// in the presence of an import statement of the form
// import {a as b} from "X";
// This function finds such implicitly indirect export entries and rewrites
// them by filling in the import name and module request, as well as nulling
// out the local name. Effectively, it turns
// import {a as b} from "X"; export {b as c};
// into:
// import {a as b} from "X"; export {a as c} from "X";
// (The import entry is never deleted.)
void MakeIndirectExportsExplicit(Zone* zone);
// Assign a cell_index of -1,-2,... to regular imports.
// Assign a cell_index of +1,+2,... to regular (local) exports.
// Assign a cell_index of 0 to anything else.
void AssignCellIndices();
int AddModuleRequest(const AstRawString* specifier,
const ImportAssertions* import_assertions,
Scanner::Location specifier_loc, Zone* zone) {
int module_requests_count = static_cast<int>(module_requests_.size());
auto it = module_requests_
zone->New<AstModuleRequest>(specifier, import_assertions),
return it->second.index;
} // namespace internal
} // namespace v8
#endif // V8_AST_MODULES_H_