Commit e8755d7

`, `SyntaxError: Unexpected token '*'. Expected a variable name for the export declaration.:2`);

`, `SyntaxError: Unexpected end of script:3`);

`, `SyntaxError: Unexpected number '42'. Expected an exported name for the export declaration.:2`);

`, `SyntaxError: Cannot export a duplicate name 'b'.:4`);

`, `SyntaxError: Unexpected end of script:3`);

2020-09-17 Yusuke Suzuki <ysuzuki@apple.com>

Support export namespace `export * as ns`

https://bugs.webkit.org/show_bug.cgi?id=214379

Reviewed by Ross Kirsling.

This patch supports `export * as ns from "module"` syntax. If it is used, we expose "module"'s namespace object as "ns".

For each module environment, we create *namespace* (starNamespace) private symbol scope variable. And we fill it later

with module namespace object. This way allows us to use module namespace object IC and super fast imported module binding

lookup though environment variable lookup mechanism.

* builtins/BuiltinNames.h:

* bytecompiler/BytecodeGenerator.cpp:

(JSC::BytecodeGenerator::BytecodeGenerator):

* parser/NodesAnalyzeModule.cpp:

(JSC::ExportNamedDeclarationNode::analyzeModule):

* parser/Parser.cpp:

(JSC::Parser<LexerType>::parseExportDeclaration):

* runtime/AbstractModuleRecord.cpp:

(JSC::AbstractModuleRecord::ExportEntry::createNamespace):

(JSC::AbstractModuleRecord::resolveExportImpl):

(JSC::AbstractModuleRecord::getModuleNamespace):

(JSC::AbstractModuleRecord::setModuleEnvironment):

(JSC::AbstractModuleRecord::dump):

* runtime/AbstractModuleRecord.h:

* runtime/CommonIdentifiers.h:

* runtime/JSFunction.cpp:

(JSC::JSFunction::name):

(JSC::JSFunction::reifyName):

* runtime/JSModuleNamespaceObject.cpp:

(JSC::JSModuleNamespaceObject::getOwnPropertySlotCommon):

* runtime/JSModuleRecord.cpp:

(JSC::JSModuleRecord::instantiateDeclarations):

(JSC::JSModuleRecord::evaluate):

* wasm/js/JSWebAssemblyModule.cpp:

(JSC::JSWebAssemblyModule::finishCreation):

* wasm/js/WebAssemblyModuleRecord.cpp:

(JSC::WebAssemblyModuleRecord::link):

macro(starNamespace) \

createVariable(m_vm.propertyNames->starNamespacePrivateName, VarKind::Scope, moduleEnvironmentSymbolTable, VerifyExisting);

//

// export * as v from "mod"

//

// If it is namespace export, we should use createNamespace.

if (specifier->localName() == analyzer.vm().propertyNames->starNamespacePrivateName)

analyzer.moduleRecord()->addExportEntry(JSModuleRecord::ExportEntry::createNamespace(specifier->exportedName(), m_moduleName->moduleName()));

else

analyzer.moduleRecord()->addExportEntry(JSModuleRecord::ExportEntry::createIndirect(specifier->exportedName(), specifier->localName(), m_moduleName->moduleName()));

// export * as IdentifierName FromClause ;

const Identifier* exportedName = nullptr;

JSTokenLocation specifierLocation;

if (matchContextualKeyword(m_vm.propertyNames->as)) {

next();

specifierLocation = JSTokenLocation(tokenLocation());

failIfFalse(matchIdentifierOrKeyword(), "Expected an exported name for the export declaration");

exportedName = m_token.m_data.ident;

next();

}

if (exportedName) {

semanticFailIfFalse(exportName(*exportedName), "Cannot export a duplicate name '", exportedName->impl(), "'");

auto specifierList = context.createExportSpecifierList();

auto localName = &m_vm.propertyNames->starNamespacePrivateName;

auto specifier = context.createExportSpecifier(specifierLocation, *localName, *exportedName);

context.appendExportSpecifier(specifierList, specifier);

return context.createExportNamedDeclaration(exportLocation, specifierList, moduleName);

}

auto AbstractModuleRecord::ExportEntry::createNamespace(const Identifier& exportName, const Identifier& moduleName) -> ExportEntry

{

return ExportEntry { Type::Namespace, exportName, moduleName, Identifier(), Identifier() };

}

case ExportEntry::Type::Namespace: {

AbstractModuleRecord* importedModuleRecord = moduleRecord->hostResolveImportedModule(globalObject, exportEntry.moduleName);

RETURN_IF_EXCEPTION(scope, Resolution::error());

Resolution resolution { Resolution::Type::Resolved, importedModuleRecord, vm.propertyNames->starNamespacePrivateName };

// 2. A module that has resolved a module namespace binding is always cacheable.

cacheResolutionForQuery(query, resolution);

if (!mergeToCurrentTop(resolution))

return Resolution::ambiguous();

continue;

}

// Materialize *namespace* slot with module namespace object unless the module environment is not yet materialized, in which case we'll do it in setModuleEnvironment

if (m_moduleEnvironment) {

bool putResult = false;

constexpr bool shouldThrowReadOnlyError = false;

constexpr bool ignoreReadOnlyErrors = true;

symbolTablePutTouchWatchpointSet(m_moduleEnvironment.get(), globalObject, vm.propertyNames->starNamespacePrivateName, moduleNamespaceObject, shouldThrowReadOnlyError, ignoreReadOnlyErrors, putResult);

RETURN_IF_EXCEPTION(scope, nullptr);

}

void AbstractModuleRecord::setModuleEnvironment(JSGlobalObject* globalObject, JSModuleEnvironment* moduleEnvironment)

{

VM& vm = globalObject->vm();

auto scope = DECLARE_THROW_SCOPE(vm);

ASSERT(!m_moduleEnvironment);

// If module namespace object is materialized, we will materialize *namespace* slot too.

if (m_moduleNamespaceObject) {

bool putResult = false;

constexpr bool shouldThrowReadOnlyError = false;

constexpr bool ignoreReadOnlyErrors = true;

symbolTablePutTouchWatchpointSet(moduleEnvironment, globalObject, vm.propertyNames->starNamespacePrivateName, m_moduleNamespaceObject.get(), shouldThrowReadOnlyError, ignoreReadOnlyErrors, putResult);

RETURN_IF_EXCEPTION(scope, void());

}

m_moduleEnvironment.set(vm, this, moduleEnvironment);

}

case ExportEntry::Type::Namespace:

dataLog(" [Namespace] ", "export(", printableName(exportEntry.exportName), "), module(", printableName(exportEntry.moduleName), ")\n");

break;