wip

Author: guybedford

document/core/appendix/embedding.rst

@@ -137,37 +137,6 @@ Modules
    \F{module\_validate}(m) &=& \ERROR && (\otherwise) \\
    \end{array}
 
-.. index:: matching, external type
-.. _embed-extern-subtype:
-
-:math:`\F{module\_extern\_subtype}(\externtype_1, \externtype_2) : \bool`
-.........................................................................
-
-1. If :math:`\externtype_1` and :math:`\externtype_2` are both of the form :math:`\ETFUNC~\functype_1` and :math:`\ETFUNC~\functype_2` respectively:
-
-   a. Return true if and only if :math:`\vdashexterntypematch \ETFUNC~\functype_1 \matchesexterntype \ETFUNC~\functype_2`.
-
-2. If :math:`\externtype_1` and :math:`\externtype_2` are both of the form :math:`\ETTABLE~\tabletype_1` and :math:`\ETTABLE~\tabletype_2` respectively:
-
-   a. Return true if and only if :math:`\vdashexterntypematch \ETTABLE~\tabletype_1 \matchesexterntype \ETTABLE~\tabletype_2`.
-
-3. If :math:`\externtype_1` and :math:`\externtype_2` are both of the form :math:`\ETMEM~\memtype_1` and :math:`\ETMEM~\memtype_2` respectively:
-
-   a. Return true if and only if :math:`\vdashexterntypematch \ETMEM~\memtype_1 \matchesexterntype \ETMEM~\memtype_2`.
-
-4. If :math:`\externtype_1` and :math:`\externtype_2` are both of the form :math:`\ETGLOBAL~\globaltype_1` and :math:`\ETGLOBAL~\globaltype_2` respectively:
-
-   a. Return true if and only if :math:`\vdashexterntypematch \ETGLOBAL~\globaltype_1 \matchesexterntype \ETGLOBAL~\globaltype_2`.
-
-5. Return false.
-
-.. math::
-   \begin{array}{lclll}
-   \F{module\_extern\_subtype}(\externtype_1, \externtype_2) &\iff& \vdashexterntypematch \externtype_1 \matchesexterntype \externtype_2 \\
-   \end{array}
-
-.. note::
-   This function encapsulates the external type matching relation defined in the :ref:`Import Subtyping <match>` of the validation section, where the :math:`\vdashexterntypematch \externtype_1 \matchesexterntype \externtype_2` judgment establishes compatibility between external types. This allows for explicit checking of type compatibility when linking modules or validating imports against exports.
 
 .. index:: instantiation, module instance
 .. _embed-module-instantiate:
@@ -249,72 +218,6 @@ Modules
    \end{array}
 
 
-.. index:: direct export
-.. _embed-direct-exports:
-
-:math:`\F{module\_direct\_exports}(\module) : (\name, \externtype)^\ast`
-........................................................................
-
-1. Pre-condition: :math:`\module` is :ref:`valid <valid-module>` with external import types :math:`\externtype^\ast` and external export types :math:`{\externtype'}^\ast`.
-
-2. Let :math:`\export^\ast` be the :ref:`exports <syntax-export>` :math:`\module.\MEXPORTS`.
-
-3. Let :math:`\X{result}` be the empty sequence.
-
-4. For each :math:`\export_i` in :math:`\export^\ast` and corresponding :math:`\externtype'_i` in :math:`{\externtype'}^\ast`, do:
-
-  a. Let :math:`\import_j = \edexportimport(\module, \export_i.\EDESC)`.
-
-  b. If :math:`\import_j = \epsilon`, then append the pair :math:`(\export_i.\ENAME, \externtype'_i)` to :math:`\X{result}`.
-
-5. Return :math:`\X{result}`.
-
-.. math::
-   ~ \\
-   \begin{array}{lclll}
-   \F{module\_direct\_exports}(m) &=& (\X{ex}.\ENAME, \externtype')^\ast \\
-     && \qquad (\iff \X{ex}^\ast = m.\MEXPORTS \\
-     && \qquad\quad \wedge~\edexportimport(m, \X{ex}.\EDESC) = \epsilon \\
-     && \qquad\quad \wedge~\vdashmodule m : \externtype^\ast \to {\externtype'}^\ast \\
-     && \qquad\quad \wedge~\externtype' = \X{ex}.\EDESC) \\
-   \end{array}
-
-
-.. index:: indirect export, re-export
-.. _embed-indirect-exports:
-
-:math:`\F{module\_indirect\_exports}(\module) : (\name, \name, \name)^\ast`
-...........................................................................
-
-1. Pre-condition: :math:`\module` is :ref:`valid <valid-module>` with external import types :math:`\externtype^\ast` and external export types :math:`{\externtype'}^\ast`.
-
-2. Let :math:`\import^\ast` be the :ref:`imports <syntax-import>` :math:`\module.\MIMPORTS`.
-
-3. Let :math:`\export^\ast` be the :ref:`exports <syntax-export>` :math:`\module.\MEXPORTS`.
-
-4. Let :math:`\X{result}` be the empty sequence.
-
-5. For each :math:`\export_i` in :math:`\export^\ast`, do:
-
-  a. Let :math:`\import_j = \edexportimport(\module, \export_i.\EDESC)`.
-
-  b. If :math:`\import_j \neq \epsilon`, then:
-
-     i. Append the triple :math:`(\export_i.\ENAME, \import_j.\IMODULE, \import_j.\INAME)` to :math:`\X{result}`.
-
-6. Return :math:`\X{result}`.
-
-.. math::
-   ~ \\
-   \begin{array}{lclll}
-   \F{module\_indirect\_exports}(m) &=& (\X{ex}.\ENAME, \X{im}.\IMODULE, \X{im}.\INAME)^\ast \\
-     && \qquad (\iff \X{ex}^\ast = m.\MEXPORTS \\
-     && \qquad\quad \wedge~\X{im} = \edexportimport(m, \X{ex}.\EDESC) \\
-     && \qquad\quad \wedge~\X{im} \neq \epsilon \\
-     && \qquad\quad \wedge~\vdashmodule m : \externtype^\ast \to {\externtype'}^\ast) \\
-   \end{array}
-
-
 .. index:: module, module instance
 .. _embed-instance:
 

document/core/syntax/modules.rst

@@ -327,7 +327,7 @@ The |MSTART| component of a module declares the :ref:`function index <syntax-fun
    The module and its exports are not accessible externally before this initialization has completed.
 
 
-.. index:: ! export, direct export, indirect export, re-export, name, index, function index, table index, memory index, global index, function, table, memory, global, instantiation
+.. index:: ! export, name, index, function index, table index, memory index, global index, function, table, memory, global, instantiation
    pair: abstract syntax; export
    single: function; export
    single: table; export
@@ -356,30 +356,6 @@ Each export is labeled by a unique :ref:`name <syntax-name>`.
 Exportable definitions are :ref:`functions <syntax-func>`, :ref:`tables <syntax-table>`, :ref:`memories <syntax-mem>`, and :ref:`globals <syntax-global>`,
 which are referenced through a respective descriptor.
 
-A *direct export* is one where the export references a function, table, memory, or global that is defined within the module itself rather than being imported. 
-
-An *indirect export* (or *re-export*) is one where the export references a function, table, memory, or global that the module imports.
-
-For an export :math:`\export` in module :math:`m`, the export is direct when :math:`\edexportimport(m, \export.\EDESC) = \epsilon` and indirect otherwise, where
-the import corresponding to an export descriptor :math:`\export.\EDESC` is defined by:
-
-.. math::
-   \begin{array}{lclll}
-   \F{exportimport}(m, \exportdesc) &=& m.\MIMPORTS[i] && (\iff \exportdesc = \EDFUNC~\funcidx \\
-     &&&& \quad \wedge~\exists~i~\colon~\funcidx = |\{j ~|~ j < i \\
-     &&&& \quad \quad \wedge~m.\MIMPORTS[j].\IDESC = \IDFUNC~\typeidx' \}|) \\
-   \F{exportimport}(m, \exportdesc) &=& m.\MIMPORTS[i] && (\iff \exportdesc = \EDTABLE~\tableidx \\
-     &&&& \quad \wedge~\exists~i~\colon~\tableidx = |\{j ~|~ j < i \\
-     &&&& \quad \quad \wedge~m.\MIMPORTS[j].\IDESC = \IDTABLE~\tabletype' \}|) \\
-   \F{exportimport}(m, \exportdesc) &=& m.\MIMPORTS[i] && (\iff \exportdesc = \EDMEM~\memidx \\
-     &&&& \quad \wedge~\exists~i~\colon~\memidx = |\{j ~|~ j < i \\
-     &&&& \quad \quad \wedge~m.\MIMPORTS[j].\IDESC = \IDMEM~\memtype' \}|) \\
-   \F{exportimport}(m, \exportdesc) &=& m.\MIMPORTS[i] && (\iff \exportdesc = \EDGLOBAL~\globalidx \\
-     &&&& \quad \wedge~\exists~i~\colon~\globalidx = |\{j ~|~ j < i \\
-     &&&& \quad \quad \wedge~m.\MIMPORTS[j].\IDESC = \IDGLOBAL~\globaltype' \}|) \\
-   \F{exportimport}(m, \exportdesc) &=& \epsilon && (\otherwise) \\
-   \end{array}
-
 
 Conventions
 ...........

document/core/util/macros.def

@@ -346,7 +346,6 @@
 .. |edtables| mathdef:: \xref{syntax/modules}{syntax-exportdesc}{\F{tables}}
 .. |edmems| mathdef:: \xref{syntax/modules}{syntax-exportdesc}{\F{mems}}
 .. |edglobals| mathdef:: \xref{syntax/modules}{syntax-exportdesc}{\F{globals}}
-.. |edexportimport| mathdef:: \xref{syntax/modules}{syntax-export}{\F{exportimport}}
 
 
 .. Instructions, terminals

document/js-api/index.bs

@@ -123,12 +123,9 @@ urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: df
     text: store_init; url: appendix/embedding.html#embed-store-init
     text: module_decode; url: appendix/embedding.html#embed-module-decode
     text: module_validate; url: appendix/embedding.html#embed-module-validate
-    text: module_extern_subtype; url: appendix/embedding.html#embed-module-extern-subtype
     text: module_instantiate; url: appendix/embedding.html#embed-module-instantiate
     text: module_imports; url: appendix/embedding.html#embed-module-imports
     text: module_exports; url: appendix/embedding.html#embed-module-exports
-    text: module_direct_exports; url: appendix/embedding.html#embed-module-direct-exports
-    text: module_inirect_exports; url: appendix/embedding.html#embed-module-indirect-exports
     text: instance_export; url: appendix/embedding.html#embed-instance-export
     text: func_alloc; url: appendix/embedding.html#embed-func-alloc
     text: func_type; url: appendix/embedding.html#embed-func-type
@@ -1394,8 +1391,6 @@ To <dfn export>parse a WebAssembly module</dfn> given a <a>byte sequence</a> |by
 1. [=list/iterate|For each=] (|moduleName|, <var ignore>name</var>, <var ignore>type</var>) in [=module_imports=](|module|.\[[Module]]),
     1. [=set/Append=] |moduleName| to |requestedModules|.
 1. Let |moduleRecord| be {
-      <!-- WebAssembly Module Records -->
-      \[[Instance]]: ~empty~,
       <!-- Abstract Module Records -->
       \[[Realm]]: |realm|,
       \[[Environment]]: ~empty~,
@@ -1445,24 +1440,8 @@ WebAssembly Module Records have the following methods:
 
 <div algorithm=ResolveExport>
 
-<h3 id="resolve-export">ResolveExport ( |exportName|, |resolveSet| ) Concrete Method</h3>
-1. If |resolveSet| is not present, set |resolveSet| to « ».
+<h3 id="resolve-export">ResolveExport ( |exportName|, <var ignore>resolveSet</var> ) Concrete Method</h3>
 1. Let |record| be this WebAssembly Module Record.
-1. Let |module| be |record|.\[[ModuleSource]].\[[Module]].
-1. [=list/iterate|For each=] Record |r| of |resolveSet|,
-    1. If |record| and |r|.\[[Module]] are the same Module Record and |exportName| is |r|.\[[ExportName]],
-        1. Return null.
-1. Append the record { \[[Module]]: |record|, \[[ExportName]]: |exportName| } to |resolveSet|.
-1. [=list/iterate|For each=] (|name|, |importedModuleName|, |importName|, <var ignore>type</var>) in [=module_indirect_exports=](|module|),
-    1. If |name| is equal to |exportName|,
-        1. Let |importedModule| be [$GetImportedModule$](|record|, |importedModuleName|).
-        1. Let |resolved| be [=?=] |importedModule|.ResolveExport(|importName|, |resolveSet|).
-        1. If |resolved| is null or ~AMBIGUOUS~,
-            1. Return |resolved|.
-        1. If |resolved|.\[[Module]] is a WebAssembly Module Record,
-            1. Return |resolved|.
-        1. Note: This fall-through case allows indirect exports referencing JS values to be treated as captured direct bindings in the environment record,
-            with live bindings unsupported. Only live bindings between Wasm globals are supported for Wasm exports.
 1. If the [=export name list=] of |record| contains |exportName|, return { \[[Module]]: |record|, \[[BindingName]]: |exportName| }.
 1. Otherwise, return null.
 
@@ -1481,23 +1460,8 @@ WebAssembly Module Records have the following methods:
 1. Let |record| be this WebAssembly Module Record.
 1. Let |env| be [$NewModuleEnvironment$](null).
 1. Set |record|.\[[Environment]] to |env|.
-1. Let |module| be |record|.\[[ModuleSource]].\[[Module]].
-1. [=list/iterate|For each=] (|importedModuleName|, |name|, <var ignore>type</var>) in [=module_imports=](|module|),
-    1. Let |importedModule| be [$GetImportedModule$](|record|, |importedModuleName|).
-    1. Let |resolution| be |importedModule|.ResolveExport(|name|).
-    1. If |resolution| is null or ~AMBIGUOUS~, throw a {{SyntaxError}} exception.
-1. [=list/iterate|For each=] (|name|, |importedModuleName|, |importName|, <var ignore>type</var>) in [=module_indirect_exports=](|module|),
-    1. Let |importedModule| be [$GetImportedModule$](|record|, |importedModuleName|).
-    1. Let |resolved| be [=?=] |importedModule|.ResolveExport(|importName|).
-    1. Assert |resolved| is not null or ~AMBIGUOUS~.
-    1. If |resolved|.\[[Module]] is not a WebAssembly Module Record,
-        1. Note: This case corresponds to indirect exports to non-WebAssembly bindings, which are always snapshotted.
-        1. Perform [=!=] |env|.CreateImmutableBinding(|name|, true).
-1. [=list/iterate|For each=] (|name|, |externtype|) of [=module_direct_exports=](|module|),
-    1. If |externtype| is of the form [=global=] [=var=] <var ignore>valtype</var>,
-        1. Perform [=!=] |env|.CreateMutableBinding(|name|, false).
-    1. Otherwise,
-        1. Perform [=!=] |env|.CreateImmutableBinding(|name|, true).
+1. For each |name| in the [=export name list=] of |record|,
+    1. Perform ! |env|.CreateImmutableBinding(|name|, true).
 
 </div>
 
@@ -1605,8 +1569,6 @@ will always reflect the current mutable global export value as interpreted throu
         1. [=list/iterate|For each=] (|moduleName|, <var ignore>name</var>, <var ignore>type</var>) in [=module_imports=](|module|),
             1. [=set/Append=] |moduleName| to |requestedModules|.
         1. Let |moduleRecord| be {
-              <!-- WebAssembly Module Records -->
-              \[[Instance]]: ~empty~,
               <!-- Abstract Module Records -->
               \[[Realm]]: |realm|,
               \[[Environment]]: ~empty~,