[MERGE #6156 @boingoing] Implement import.meta

Merge pull request #6156 from boingoing:importmeta

Implement import.meta

The import.meta proposal has reached stage 3. See details:
https://github.com/tc39/proposal-import-meta

This special name is a meta-property which binds to an object in module code. The import.meta object is unique per-module. Each module's import.meta object is filled-out with properties provided by the host. The object itself is lazily-created and an empty object with a null prototype by default.

When loading import.meta for a module, we ask the host to provide a set of properties for the object and allow the host to do other setup of the import.meta object it might need to do. There are two host API provided for in the proposal: HostGetImportMetaProperties and HostFinalizeImportMeta. I've plumbed these callbacks in so hosts can implement them.

Author: boingoing

bin/NativeTests/JsRTApiTest.cpp

@@ -2191,7 +2191,7 @@ namespace JsRTApiTest
         return JsNoError;
     }
 
-    static JsErrorCode CALLBACK Succes_NMRC(_In_opt_ JsModuleRecord referencingModule, _In_opt_ JsValueRef exceptionVar)
+    static JsErrorCode CALLBACK Success_NMRC(_In_opt_ JsModuleRecord referencingModule, _In_opt_ JsValueRef exceptionVar)
     {
         if (successTest.mainModule == referencingModule)
         {
@@ -2201,6 +2201,11 @@ namespace JsRTApiTest
         return JsNoError;
     }
 
+    static JsErrorCode CALLBACK Success_IIMC(_In_opt_ JsModuleRecord referencingModule, _In_opt_ JsValueRef importMetaVar)
+    {
+        return JsNoError;
+    }
+
     void ModuleSuccessTest(JsRuntimeAttributes attributes, JsRuntimeHandle runtime)
     {
         JsModuleRecord requestModule = JS_INVALID_REFERENCE;
@@ -2211,7 +2216,8 @@ namespace JsRTApiTest
         successTest.mainModule = requestModule;
         REQUIRE(JsSetModuleHostInfo(requestModule, JsModuleHostInfo_FetchImportedModuleCallback, Success_FIMC) == JsNoError);
         REQUIRE(JsSetModuleHostInfo(requestModule, JsModuleHostInfo_FetchImportedModuleFromScriptCallback, Success_FIMC) == JsNoError);
-        REQUIRE(JsSetModuleHostInfo(requestModule, JsModuleHostInfo_NotifyModuleReadyCallback, Succes_NMRC) == JsNoError);
+        REQUIRE(JsSetModuleHostInfo(requestModule, JsModuleHostInfo_NotifyModuleReadyCallback, Success_NMRC) == JsNoError);
+        REQUIRE(JsSetModuleHostInfo(requestModule, JsModuleHostInfo_InitializeImportMetaCallback, Success_IIMC) == JsNoError);
 
         JsValueRef errorObject = JS_INVALID_REFERENCE;
         const char* fileContent = "import {x} from 'foo.js'";
@@ -2279,7 +2285,7 @@ namespace JsRTApiTest
         REQUIRE(JsInitializeModuleRecord(nullptr, specifier, &requestModule) == JsNoError);
 
         successTest.mainModule = requestModule;
-        REQUIRE(JsSetModuleHostInfo(requestModule, JsModuleHostInfo_NotifyModuleReadyCallback, Succes_NMRC) == JsNoError);
+        REQUIRE(JsSetModuleHostInfo(requestModule, JsModuleHostInfo_NotifyModuleReadyCallback, Success_NMRC) == JsNoError);
 
         // Parsing
         JsValueRef errorObject1 = JS_INVALID_REFERENCE;
@@ -2327,7 +2333,7 @@ namespace JsRTApiTest
         successTest.mainModule = requestModule;
         REQUIRE(JsSetModuleHostInfo(requestModule, JsModuleHostInfo_FetchImportedModuleCallback, Success_FIMC1) == JsNoError);
         REQUIRE(JsSetModuleHostInfo(requestModule, JsModuleHostInfo_FetchImportedModuleFromScriptCallback, Success_FIMC1) == JsNoError);
-        REQUIRE(JsSetModuleHostInfo(requestModule, JsModuleHostInfo_NotifyModuleReadyCallback, Succes_NMRC) == JsNoError);
+        REQUIRE(JsSetModuleHostInfo(requestModule, JsModuleHostInfo_NotifyModuleReadyCallback, Success_NMRC) == JsNoError);
 
         JsValueRef errorObject = JS_INVALID_REFERENCE;
         const char* fileContent = "import {x} from 'foo.js'";

bin/ch/WScriptJsrt.cpp

@@ -612,9 +612,14 @@ JsErrorCode WScriptJsrt::InitializeModuleInfo(JsValueRef specifier, JsModuleReco
         {
             errorCode = ChakraRTInterface::JsSetModuleHostInfo(moduleRecord, JsModuleHostInfo_NotifyModuleReadyCallback, (void*)WScriptJsrt::NotifyModuleReadyCallback);
 
-            if (errorCode == JsNoError && moduleRecord != nullptr)
+            if (errorCode == JsNoError)
             {
-                errorCode = ChakraRTInterface::JsSetModuleHostInfo(moduleRecord, JsModuleHostInfo_HostDefined, specifier);
+                errorCode = ChakraRTInterface::JsSetModuleHostInfo(moduleRecord, JsModuleHostInfo_InitializeImportMetaCallback, (void*)WScriptJsrt::InitializeImportMetaCallback);
+
+                if (errorCode == JsNoError && moduleRecord != nullptr)
+                {
+                    errorCode = ChakraRTInterface::JsSetModuleHostInfo(moduleRecord, JsModuleHostInfo_HostDefined, specifier);
+                }
             }
         }
     }
@@ -2159,6 +2164,23 @@ JsErrorCode WScriptJsrt::NotifyModuleReadyCallback(_In_opt_ JsModuleRecord refer
     return JsNoError;
 }
 
+JsErrorCode __stdcall WScriptJsrt::InitializeImportMetaCallback(_In_opt_ JsModuleRecord referencingModule, _In_opt_ JsValueRef importMetaVar)
+{
+    if (importMetaVar != nullptr)
+    {
+        JsValueRef specifier = JS_INVALID_REFERENCE;
+        ChakraRTInterface::JsGetModuleHostInfo(referencingModule, JsModuleHostInfo_HostDefined, &specifier);
+
+        JsPropertyIdRef urlPropId;
+        if (JsNoError == CreatePropertyIdFromString("url", &urlPropId))
+        {
+            ChakraRTInterface::JsSetProperty(importMetaVar, urlPropId, specifier, false);
+        }
+    }
+
+    return JsNoError;
+}
+
 void WScriptJsrt::PromiseContinuationCallback(JsValueRef task, void *callbackState)
 {
     Assert(task != JS_INVALID_REFERENCE);

bin/ch/WScriptJsrt.h

@@ -65,6 +65,7 @@ class WScriptJsrt
     static JsErrorCode FetchImportedModule(_In_ JsModuleRecord referencingModule, _In_ JsValueRef specifier, _Outptr_result_maybenull_ JsModuleRecord* dependentModuleRecord);
     static JsErrorCode FetchImportedModuleFromScript(_In_ DWORD_PTR dwReferencingSourceContext, _In_ JsValueRef specifier, _Outptr_result_maybenull_ JsModuleRecord* dependentModuleRecord);
     static JsErrorCode NotifyModuleReadyCallback(_In_opt_ JsModuleRecord referencingModule, _In_opt_ JsValueRef exceptionVar);
+    static JsErrorCode CALLBACK InitializeImportMetaCallback(_In_opt_ JsModuleRecord referencingModule, _In_opt_ JsValueRef importMetaVar);
     static JsErrorCode InitializeModuleCallbacks();
     static void CALLBACK PromiseContinuationCallback(JsValueRef task, void *callbackState);
     static void CALLBACK PromiseRejectionTrackerCallback(JsValueRef promise, JsValueRef reason, bool handled, void *callbackState);

lib/Backend/JnHelperMethodList.h

@@ -532,6 +532,7 @@ HELPERCALLCHK(LdHomeObjProto,           Js::JavascriptOperators::OP_LdHomeObjPro
 HELPERCALLCHK(LdFuncObjProto,           Js::JavascriptOperators::OP_LdFuncObjProto, AttrCanNotBeReentrant)
 
 HELPERCALLCHK(ImportCall,               Js::JavascriptOperators::OP_ImportCall, 0)
+HELPERCALLCHK(LdImportMeta,             Js::JavascriptOperators::OP_LdImportMeta, 0)
 HELPERCALLCHK(NewAsyncFromSyncIterator, Js::JavascriptOperators::OP_NewAsyncFromSyncIterator, AttrCanNotBeReentrant)
 
 HELPERCALLCHK(AsyncYieldIsReturn,       Js::JavascriptOperators::OP_AsyncYieldIsReturn, AttrCanNotBeReentrant)

lib/Backend/Lower.cpp

@@ -2531,6 +2531,16 @@ Lowerer::LowerRange(IR::Instr *instrStart, IR::Instr *instrEnd, bool defaultDoFa
             this->GenerateCheckForCallFlagNew(instr);
             break;
 
+        case Js::OpCode::LdImportMeta:
+        {
+            IR::Opnd *src1Opnd = instr->UnlinkSrc1();
+
+            LoadScriptContext(instr);
+            m_lowererMD.LoadHelperArgument(instr, src1Opnd);
+            m_lowererMD.ChangeToHelperCall(instr, IR::HelperLdImportMeta);
+            break;
+        }
+
         case Js::OpCode::StFuncExpr:
             // object.propid = src
             LowerStFld(instr, IR::HelperOp_StFunctionExpression, IR::HelperOp_StFunctionExpression, false);

lib/Common/ConfigFlagsList.h

@@ -702,6 +702,7 @@ PHASE(All)
 #define DEFAULT_CONFIG_ES7ValuesEntries        (true)
 #define DEFAULT_CONFIG_ESObjectGetOwnPropertyDescriptors (true)
 #define DEFAULT_CONFIG_ESDynamicImport         (false)
+#define DEFAULT_CONFIG_ESImportMeta            (true)
 #define DEFAULT_CONFIG_ESExportNsAs            (true)
 #define DEFAULT_CONFIG_ES2018AsyncIteration    (false)
 
@@ -1228,6 +1229,9 @@ FLAGR(Boolean, ESHashbang, "Enable Hashbang syntax", DEFAULT_CONFIG_ESHashbang)
 // ES Symbol.prototype.description flag
 FLAGR(Boolean, ESSymbolDescription, "Enable Symbol.prototype.description", DEFAULT_CONFIG_ESSymbolDescription)
 
+// ES import.meta keyword meta-property
+FLAGR(Boolean, ESImportMeta, "Enable import.meta keyword", DEFAULT_CONFIG_ESImportMeta)
+
 //ES globalThis flag
 FLAGR(Boolean, ESGlobalThis, "Enable globalThis", DEFAULT_CONFIG_ESGlobalThis)
 

lib/Jsrt/ChakraCore.h

@@ -111,7 +111,11 @@ typedef enum JsModuleHostInfoKind
     /// <summary>
     ///     URL for use in error stack traces and debugging.
     /// </summary>
-    JsModuleHostInfo_Url = 0x6
+    JsModuleHostInfo_Url = 0x6,
+    /// <summary>
+    ///     Callback to allow host to initialize import.meta object properties.
+    /// </summary>
+    JsModuleHostInfo_InitializeImportMetaCallback = 0x7
 } JsModuleHostInfoKind;
 
 /// <summary>
@@ -187,6 +191,22 @@ typedef JsErrorCode(CHAKRA_CALLBACK * FetchImportedModuleFromScriptCallBack)(_In
 /// </returns>
 typedef JsErrorCode(CHAKRA_CALLBACK * NotifyModuleReadyCallback)(_In_opt_ JsModuleRecord referencingModule, _In_opt_ JsValueRef exceptionVar);
 
+/// <summary>
+///     User implemented callback to fill in module properties for the import.meta object.
+/// </summary>
+/// <remarks>
+///     This callback allows the host to fill module details for the referencing module in the import.meta object
+///     loaded by script.
+///     The callback is invoked on the current runtime execution thread, therefore execution is blocked until the
+///     callback completes.
+/// </remarks>
+/// <param name="referencingModule">The referencing module that is loading an import.meta object.</param>
+/// <param name="importMetaVar">The object which will be returned to script for the referencing module.</param>
+/// <returns>
+///     Returns a JsErrorCode - note, the return value is ignored.
+/// </returns>
+typedef JsErrorCode(CHAKRA_CALLBACK * InitializeImportMetaCallback)(_In_opt_ JsModuleRecord referencingModule, _In_opt_ JsValueRef importMetaVar);
+
 /// <summary>
 ///     A structure containing information about a native function callback.
 /// </summary>

lib/Jsrt/Core/JsrtContextCore.cpp

@@ -159,6 +159,23 @@ HRESULT ChakraCoreHostScriptContext::NotifyHostAboutModuleReady(Js::ModuleRecord
     return E_INVALIDARG;
 }
 
+HRESULT ChakraCoreHostScriptContext::InitializeImportMeta(Js::ModuleRecordBase* referencingModule, Js::Var importMetaObject)
+{
+    if (initializeImportMetaCallback == nullptr)
+    {
+        return E_INVALIDARG;
+    }
+    {
+        AUTO_NO_EXCEPTION_REGION;
+        JsErrorCode errorCode = initializeImportMetaCallback(referencingModule, importMetaObject);
+        if (errorCode == JsNoError)
+        {
+            return NOERROR;
+        }
+    }
+    return E_INVALIDARG;
+}
+
 ChakraCoreStreamWriter::~ChakraCoreStreamWriter()
 {
     HeapDelete(m_serializerCore);

lib/Jsrt/Core/JsrtContextCore.h

@@ -101,8 +101,10 @@ class ChakraCoreHostScriptContext sealed : public HostScriptContext
 public:
     ChakraCoreHostScriptContext(Js::ScriptContext* scriptContext)
         : HostScriptContext(scriptContext),
+        fetchImportedModuleCallback(nullptr),
+        fetchImportedModuleFromScriptCallback(nullptr),
         notifyModuleReadyCallback(nullptr),
-        fetchImportedModuleCallback(nullptr)
+        initializeImportMetaCallback(nullptr)
     {
     }
     ~ChakraCoreHostScriptContext()
@@ -250,6 +252,8 @@ class ChakraCoreHostScriptContext sealed : public HostScriptContext
 
     HRESULT NotifyHostAboutModuleReady(Js::ModuleRecordBase* referencingModule, Js::Var exceptionVar) override;
 
+    HRESULT InitializeImportMeta(Js::ModuleRecordBase* referencingModule, Js::Var importMetaObject) override;
+
     void SetNotifyModuleReadyCallback(NotifyModuleReadyCallback notifyCallback) { this->notifyModuleReadyCallback = notifyCallback; }
     NotifyModuleReadyCallback GetNotifyModuleReadyCallback() const { return this->notifyModuleReadyCallback; }
 
@@ -259,6 +263,9 @@ class ChakraCoreHostScriptContext sealed : public HostScriptContext
     void SetFetchImportedModuleFromScriptCallback(FetchImportedModuleFromScriptCallBack fetchCallback) { this->fetchImportedModuleFromScriptCallback = fetchCallback; }
     FetchImportedModuleFromScriptCallBack GetFetchImportedModuleFromScriptCallback() const { return this->fetchImportedModuleFromScriptCallback; }
 
+    void SetInitializeImportMetaCallback(InitializeImportMetaCallback finalizeCallback) { this->initializeImportMetaCallback = finalizeCallback; }
+    InitializeImportMetaCallback GetInitializeImportMetaCallback() const { return this->initializeImportMetaCallback; }
+
 #if DBG_DUMP || defined(PROFILE_EXEC) || defined(PROFILE_MEM)
     void EnsureParentInfo(Js::ScriptContext* scriptContext = NULL) override
     {
@@ -273,7 +280,5 @@ class ChakraCoreHostScriptContext sealed : public HostScriptContext
     FetchImportedModuleCallBack fetchImportedModuleCallback;
     FetchImportedModuleFromScriptCallBack fetchImportedModuleFromScriptCallback;
     NotifyModuleReadyCallback notifyModuleReadyCallback;
+    InitializeImportMetaCallback initializeImportMetaCallback;
 };
-
-
-

lib/Jsrt/Core/JsrtCore.cpp

@@ -158,7 +158,8 @@ JsSetModuleHostInfo(
     {
         if (moduleHostInfo != JsModuleHostInfo_FetchImportedModuleCallback &&
             moduleHostInfo != JsModuleHostInfo_FetchImportedModuleFromScriptCallback &&
-            moduleHostInfo != JsModuleHostInfo_NotifyModuleReadyCallback)
+            moduleHostInfo != JsModuleHostInfo_NotifyModuleReadyCallback &&
+            moduleHostInfo != JsModuleHostInfo_InitializeImportMetaCallback)
         {
             return JsErrorInvalidArgument;
         }
@@ -191,6 +192,9 @@ JsSetModuleHostInfo(
         case JsModuleHostInfo_NotifyModuleReadyCallback:
             currentContext->GetHostScriptContext()->SetNotifyModuleReadyCallback(reinterpret_cast<NotifyModuleReadyCallback>(hostInfo));
             break;
+        case JsModuleHostInfo_InitializeImportMetaCallback:
+            currentContext->GetHostScriptContext()->SetInitializeImportMetaCallback(reinterpret_cast<InitializeImportMetaCallback>(hostInfo));
+            break;
         case JsModuleHostInfo_Url:
             moduleRecord->SetModuleUrl(hostInfo);
             break;
@@ -238,6 +242,9 @@ JsGetModuleHostInfo(
         case JsModuleHostInfo_NotifyModuleReadyCallback:
             *hostInfo = reinterpret_cast<void*>(currentContext->GetHostScriptContext()->GetNotifyModuleReadyCallback());
             break;
+        case JsModuleHostInfo_InitializeImportMetaCallback:
+            *hostInfo = reinterpret_cast<void*>(currentContext->GetHostScriptContext()->GetInitializeImportMetaCallback());
+            break;
         case JsModuleHostInfo_Url:
             *hostInfo = reinterpret_cast<void*>(moduleRecord->GetModuleUrl());
             break;