Script location should be passed to module resolver (#1740)

sebastienros · Jan 13, 2024 · dc20829 · dc20829
1 parent a178818
commit dc20829
Show file tree

Hide file tree

Showing 5 changed files with 134 additions and 5 deletions.
diff --git a/Jint.Tests/Runtime/ModuleTests.cs b/Jint.Tests/Runtime/ModuleTests.cs
@@ -1,5 +1,6 @@
 using Jint.Native;
 using Jint.Runtime;
+using Jint.Runtime.Modules;
 
 namespace Jint.Tests.Runtime;
 
@@ -365,6 +366,134 @@ public void CanReuseModule()
         }
     }
 
+    [Fact]
+    public void EngineExecutePassesSourceForModuleResolving()
+    {
+        var moduleLoader = new EnforceRelativeModuleLoader(new Dictionary<string, string>()
+        {
+            ["file:///folder/my-module.js"] = "export const value = 'myModuleConst'"
+        });
+        var engine = new Engine(options => options.EnableModules(moduleLoader));
+        var code = @"
+(async () => {
+    const { value } = await import('./my-module.js');
+    log(value);
+})();
+";
+        List<string> logStatements = new List<string>();
+        engine.SetValue("log", logStatements.Add);
+
+        engine.Execute(code, source: "file:///folder/main.js");
+        engine.Advanced.ProcessTasks();
+
+        Assert.Collection(
+            logStatements,
+            s => Assert.Equal("myModuleConst", s));
+    }
+
+    [Fact]
+    public void EngineExecuteUsesScriptSourceForSource()
+    {
+        var moduleLoader = new EnforceRelativeModuleLoader(new Dictionary<string, string>()
+        {
+            ["file:///folder/my-module.js"] = "export const value = 'myModuleConst'"
+        });
+        var engine = new Engine(options => options.EnableModules(moduleLoader));
+        var code = @"
+(async () => {
+    const { value } = await import('./my-module.js');
+    log(value);
+})();
+";
+        List<string> logStatements = new List<string>();
+        engine.SetValue("log", logStatements.Add);
+
+        var script = Engine.PrepareScript(code, source: "file:///folder/main.js");
+        engine.Execute(script);
+        engine.Advanced.ProcessTasks();
+
+        Assert.Collection(
+            logStatements,
+            s => Assert.Equal("myModuleConst", s));
+    }
+
+    [Fact]
+    public void EngineEvaluatePassesSourceForModuleResolving()
+    {
+        var moduleLoader = new EnforceRelativeModuleLoader(new Dictionary<string, string>()
+        {
+            ["file:///folder/my-module.js"] = "export const value = 'myModuleConst'"
+        });
+        var engine = new Engine(options => options.EnableModules(moduleLoader));
+        var code = @"
+(async () => {
+    const { value } = await import('./my-module.js');
+    log(value);
+})();
+";
+        List<string> logStatements = new List<string>();
+        engine.SetValue("log", logStatements.Add);
+
+        engine.Evaluate(code, source: "file:///folder/main.js");
+        engine.Advanced.ProcessTasks();
+
+        Assert.Collection(
+            logStatements,
+            s => Assert.Equal("myModuleConst", s));
+    }
+
+    [Fact]
+    public void EngineEvaluateUsesScriptSourceForSource()
+    {
+        var moduleLoader = new EnforceRelativeModuleLoader(new Dictionary<string, string>()
+        {
+            ["file:///folder/my-module.js"] = "export const value = 'myModuleConst'"
+        });
+        var engine = new Engine(options => options.EnableModules(moduleLoader));
+        var code = @"
+(async () => {
+    const { value } = await import('./my-module.js');
+    log(value);
+})();
+";
+        List<string> logStatements = new List<string>();
+        engine.SetValue("log", logStatements.Add);
+
+        var script = Engine.PrepareScript(code, source: "file:///folder/main.js");
+        engine.Evaluate(script);
+        engine.Advanced.ProcessTasks();
+
+        Assert.Collection(
+            logStatements,
+            s => Assert.Equal("myModuleConst", s));
+    }
+
+    private sealed class EnforceRelativeModuleLoader : IModuleLoader
+    {
+        private readonly IReadOnlyDictionary<string, string> _modules;
+
+        public EnforceRelativeModuleLoader(IReadOnlyDictionary<string, string> modules)
+        {
+            _modules = modules;
+        }
+
+        public ResolvedSpecifier Resolve(string referencingModuleLocation, ModuleRequest moduleRequest)
+        {
+            Assert.False(string.IsNullOrEmpty(referencingModuleLocation), "Referencing module location is null or empty");
+            var target = new Uri(new Uri(referencingModuleLocation, UriKind.Absolute), moduleRequest.Specifier);
+            Assert.True(_modules.ContainsKey(target.ToString()), $"Resolve was called with unexpected module request, {moduleRequest.Specifier} relative to {referencingModuleLocation}");
+            return new ResolvedSpecifier(moduleRequest, target.ToString(), target, SpecifierType.Bare);
+        }
+
+        public Module LoadModule(Engine engine, ResolvedSpecifier resolved)
+        {
+            Assert.NotNull(resolved.Uri);
+            var source = resolved.Uri.ToString();
+            Assert.True(_modules.TryGetValue(source, out var script), $"Resolved module does not exist: {source}");
+            return ModuleFactory.BuildSourceTextModule(engine, Engine.PrepareModule(script, source));
+        }
+    }
+
     private static string GetBasePath()
     {
         var assemblyDirectory = new DirectoryInfo(AppDomain.CurrentDomain.RelativeSearchPath ?? AppDomain.CurrentDomain.BaseDirectory);

diff --git a/Jint/Engine.Modules.cs b/Jint/Engine.Modules.cs
@@ -113,7 +113,7 @@ internal ObjectInstance Import(ModuleRequest request, string? referencingModuleL
 
             if (!_modules.TryGetValue(moduleResolution.Key, out var module))
             {
-                module = Load(referencingModuleLocation: null, request);
+                module = Load(referencingModuleLocation, request);
             }
 
             if (module is not CyclicModule cyclicModule)

diff --git a/Jint/Engine.cs b/Jint/Engine.cs
@@ -376,7 +376,7 @@ public Engine Execute(string code, string source, ParserOptions parserOptions)
         public Engine Execute(Script script)
         {
             var strict = _isStrict || script.Strict;
-            ExecuteWithConstraints(strict, () => ScriptEvaluation(new ScriptRecord(Realm, script, string.Empty)));
+            ExecuteWithConstraints(strict, () => ScriptEvaluation(new ScriptRecord(Realm, script, script.Location.Source)));
 
             return this;
         }
@@ -1594,7 +1594,7 @@ public void Dispose()
             clearMethod?.Invoke(_objectWrapperCache, Array.Empty<object>());
 #endif
         }
-        
+
         [DebuggerDisplay("Engine")]
         private sealed class EngineDebugView
         {

diff --git a/Jint/Runtime/IScriptOrModule.cs b/Jint/Runtime/IScriptOrModule.cs
@@ -2,5 +2,5 @@ namespace Jint.Runtime;
 
 internal interface IScriptOrModule
 {
-    public string Location { get; }
+    public string? Location { get; }
 }
diff --git a/Jint/Runtime/ScriptRecord.cs b/Jint/Runtime/ScriptRecord.cs
@@ -2,4 +2,4 @@
 
 namespace Jint.Runtime;
 
-internal sealed record ScriptRecord(Realm Realm, Script EcmaScriptCode, string Location) : IScriptOrModule;
+internal sealed record ScriptRecord(Realm Realm, Script EcmaScriptCode, string? Location) : IScriptOrModule;