Improve AOT usage scenarios with metadata (#1764)

* create AOT example project * set REPL for AOT publish * extract reflection related helpers from TypeConverter to InteropHelper
sebastienros · Jan 27, 2024 · 9fbdab3 · 9fbdab3
1 parent 0946a9f
commit 9fbdab3
Show file tree

Hide file tree

Showing 34 changed files with 595 additions and 406 deletions.
diff --git a/Jint.AotExample/Jint.AotExample.csproj b/Jint.AotExample/Jint.AotExample.csproj
@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+    <PublishAot>true</PublishAot>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Jint\Jint.csproj" />
+    <TrimmerRootAssembly Include="Jint" />
+  </ItemGroup>
+
+</Project>
diff --git a/Jint.AotExample/Program.cs b/Jint.AotExample/Program.cs
@@ -0,0 +1,22 @@
+using Jint;
+
+var engine = new Engine(cfg => cfg
+    .AllowClr()
+);
+
+engine.SetValue("company", new Company());
+
+Console.WriteLine($"Company's name: {engine.Evaluate("company.name")}");
+Console.WriteLine($"Company's field: {engine.Evaluate("company.field")}");
+Console.WriteLine($"Company's indexer: {engine.Evaluate("company[42]")}");
+Console.WriteLine($"Company's greeting: {engine.Evaluate("company.sayHello('Mary')")}");
+
+
+public class Company
+{
+    public string Field = "public field value";
+    public string Name => "Jint";
+    public string SayHello(string name) => $"Hello {name}!";
+    public int this[int index] => index;
+}
+
diff --git a/Jint.Repl/Jint.Repl.csproj b/Jint.Repl/Jint.Repl.csproj
@@ -4,8 +4,10 @@
     <OutputType>Exe</OutputType>
     <IsPackable>false</IsPackable>
     <ImplicitUsings>enable</ImplicitUsings>
+    <PublishAot>true</PublishAot>
   </PropertyGroup>
   <ItemGroup>
     <ProjectReference Include="..\Jint\Jint.csproj" />
+    <TrimmerRootAssembly Include="Jint" />
   </ItemGroup>
 </Project>
diff --git a/Jint.Repl/Program.cs b/Jint.Repl/Program.cs
@@ -1,11 +1,13 @@
-using System.Diagnostics;
-using System.Reflection;
+using System.Reflection;
 using Esprima;
 using Jint;
 using Jint.Native;
 using Jint.Native.Json;
 using Jint.Runtime;
 
+#pragma warning disable IL2026
+#pragma warning disable IL2111
+
 var engine = new Engine(cfg => cfg
     .AllowClr()
 );
@@ -30,8 +32,7 @@
 }
 
 var assembly = Assembly.GetExecutingAssembly();
-var fvi = FileVersionInfo.GetVersionInfo(assembly.Location);
-var version = fvi.FileVersion;
+var version = assembly.GetName().Version?.ToString();
 
 Console.WriteLine("Welcome to Jint ({0})", version);
 Console.WriteLine("Type 'exit' to leave, " +

diff --git a/Jint.Tests.PublicInterface/Jint.Tests.PublicInterface.csproj b/Jint.Tests.PublicInterface/Jint.Tests.PublicInterface.csproj
@@ -9,6 +9,7 @@
     <LangVersion>latest</LangVersion>
     <NoWarn>612</NoWarn>
     <ImplicitUsings>enable</ImplicitUsings>
+    <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
   </PropertyGroup>
 
 

diff --git a/Jint.Tests/Runtime/EngineTests.cs b/Jint.Tests/Runtime/EngineTests.cs
@@ -602,14 +602,15 @@ public void EvalFunctionParseAndExecuteCode()
         [Fact]
         public void ForInStatement()
         {
-            RunTest(@"
+            var engine = new Engine();
+            var result = engine.Evaluate("""
                 var x, y, str = '';
                 for(var z in this) {
-                    str += z;
+                 str += z;
                 }
-
-                equal('xystrz', str);
-            ");
+                return str;
+         """);
+            Assert.Equal("xystrz", result);
         }
 
         [Fact]

diff --git a/Jint.Tests/Runtime/InteropTests.cs b/Jint.Tests/Runtime/InteropTests.cs
@@ -3431,7 +3431,7 @@ public void ShouldRespectConcreteGenericReturnTypes()
             });
 
             var result = new List<string>();
-            void Debug(object? o)
+            void Debug(object o)
             {
                 result.Add($"{o?.GetType().Name ?? "null"}: {o ?? "null"}");
             }

diff --git a/Jint.sln b/Jint.sln
@@ -25,6 +25,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		Directory.Build.props = Directory.Build.props
 	EndProjectSection
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Jint.AotExample", "Jint.AotExample\Jint.AotExample.csproj", "{E07CC7D2-2ADF-4D71-A5B1-88209FFC29CD}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -59,6 +61,10 @@ Global
 		{70198CE9-7DFE-40CA-BBAC-1454C92C4109}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{70198CE9-7DFE-40CA-BBAC-1454C92C4109}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{70198CE9-7DFE-40CA-BBAC-1454C92C4109}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E07CC7D2-2ADF-4D71-A5B1-88209FFC29CD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E07CC7D2-2ADF-4D71-A5B1-88209FFC29CD}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E07CC7D2-2ADF-4D71-A5B1-88209FFC29CD}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E07CC7D2-2ADF-4D71-A5B1-88209FFC29CD}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

diff --git a/Jint/Engine.cs b/Jint/Engine.cs
@@ -1,4 +1,5 @@
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using Esprima;
 using Esprima.Ast;
@@ -227,7 +228,7 @@ internal ExecutionContext EnterExecutionContext(in ExecutionContext context)
         /// </summary>
         public Engine SetValue(string name, Delegate value)
         {
-            Realm.GlobalObject.FastSetProperty(name, new PropertyDescriptor(new DelegateWrapper(this, value), true, false, true));
+            Realm.GlobalObject.FastSetProperty(name, new PropertyDescriptor(new DelegateWrapper(this, value), PropertyFlag.NonEnumerable));
             return this;
         }
 
@@ -244,23 +245,23 @@ public Engine SetValue(string name, string? value)
         /// </summary>
         public Engine SetValue(string name, double value)
         {
-            return SetValue(name, JsNumber.Create(value));
+            return SetValue(name, (JsValue) JsNumber.Create(value));
         }
 
         /// <summary>
         /// Registers an integer value as variable.
         /// </summary>
         public Engine SetValue(string name, int value)
         {
-            return SetValue(name, JsNumber.Create(value));
+            return SetValue(name, (JsValue) JsNumber.Create(value));
         }
 
         /// <summary>
         /// Registers a boolean value as variable.
         /// </summary>
         public Engine SetValue(string name, bool value)
         {
-            return SetValue(name, value ? JsBoolean.True : JsBoolean.False);
+            return SetValue(name, (JsValue) (value ? JsBoolean.True : JsBoolean.False));
         }
 
         /// <summary>
@@ -273,7 +274,7 @@ public Engine SetValue(string name, JsValue value)
         }
 
         /// <summary>
-        /// Registers an object value as variable, creates an interop wrapper when needed..
+        /// Registers an object value as variable, creates an interop wrapper when needed.
         /// </summary>
         public Engine SetValue(string name, object? obj)
         {
@@ -284,6 +285,26 @@ public Engine SetValue(string name, object? obj)
             return SetValue(name, value);
         }
 
+        /// <summary>
+        /// Registers an object value as variable, creates an interop wrapper when needed.
+        /// </summary>
+        public Engine SetValue(string name, [DynamicallyAccessedMembers(InteropHelper.DefaultDynamicallyAccessedMemberTypes)] Type type)
+        {
+#pragma warning disable IL2111
+            return SetValue(name, TypeReference.CreateTypeReference(this, type));
+#pragma warning restore IL2111
+        }
+
+        /// <summary>
+        /// Registers an object value as variable, creates an interop wrapper when needed.
+        /// </summary>
+        public Engine SetValue<[DynamicallyAccessedMembers(InteropHelper.DefaultDynamicallyAccessedMemberTypes)] T>(string name, T? obj)
+        {
+            return obj is Type t
+                ? SetValue(name, t)
+                : SetValue(name, JsValue.FromObject(this, obj));
+        }
+
         internal void LeaveExecutionContext()
         {
             _executionContexts.Pop();

diff --git a/Jint/Extensions/ReflectionExtensions.cs b/Jint/Extensions/ReflectionExtensions.cs
@@ -41,21 +41,21 @@ internal static Type GetDefinedType(this MemberInfo memberInfo)
             };
         }
 
-        internal static IEnumerable<MethodInfo> GetExtensionMethods(this Type type)
+        internal static IEnumerable<MethodInfo> GetExtensionMethods([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] this Type type)
         {
             return type.GetMethods(BindingFlags.Public | BindingFlags.Static)
                 .Where(static m => m.IsExtensionMethod());
         }
 
-        internal static IEnumerable<MethodInfo> GetOperatorOverloadMethods(this Type type)
+        internal static IEnumerable<MethodInfo> GetOperatorOverloadMethods([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] this Type type)
         {
             return type.GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy)
                 .Where(static m => m.IsSpecialName);
         }
 
         private static bool IsExtensionMethod(this MethodBase methodInfo)
         {
-            return methodInfo.IsDefined(typeof(ExtensionAttribute), true);
+            return methodInfo.IsDefined(typeof(ExtensionAttribute), inherit: true);
         }
 
         public static bool IsNullable(this Type type)

diff --git a/Jint/Jint.csproj b/Jint/Jint.csproj
@@ -19,6 +19,11 @@
 
     <NoWarn>$(NoWarn);1591</NoWarn>
 
+    <IsAotCompatible Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net7.0'))">true</IsAotCompatible>
+
+    <PolySharpExcludeGeneratedTypes>System.Runtime.CompilerServices.IsExternalInit;System.Runtime.CompilerServices.RequiresLocationAttribute</PolySharpExcludeGeneratedTypes>
+    <PolySharpIncludeRuntimeSupportedAttributes>true</PolySharpIncludeRuntimeSupportedAttributes>
+
   </PropertyGroup>
 
   <PropertyGroup Condition=" '$(TargetFramework)' != 'net462' and '$(TargetFramework)' != 'netstandard2.0' ">

diff --git a/Jint/Native/ShadowRealm/ShadowRealm.cs b/Jint/Native/ShadowRealm/ShadowRealm.cs
@@ -1,4 +1,5 @@
-using Esprima;
+using System.Diagnostics.CodeAnalysis;
+using Esprima;
 using Esprima.Ast;
 using Esprima.Utils;
 using Jint.Native.Object;
@@ -55,9 +56,11 @@ public JsValue ImportValue(string specifier, string exportName)
         _engine.RunAvailableContinuations();
         return value;
     }
+
+    [RequiresUnreferencedCode("User supplied delegate")]
     public ShadowRealm SetValue(string name, Delegate value)
     {
-        _shadowRealm.GlobalObject.FastSetProperty(name, new PropertyDescriptor(new DelegateWrapper(_engine, value), true, false, true));
+        _shadowRealm.GlobalObject.FastSetProperty(name, new PropertyDescriptor(new DelegateWrapper(_engine, value), PropertyFlag.NonEnumerable));
         return this;
     }
 

diff --git a/Jint/Options.cs b/Jint/Options.cs
@@ -114,17 +114,20 @@ internal void Apply(Engine engine)
             // add missing bits if needed
             if (Interop.Enabled)
             {
-                engine.Realm.GlobalObject.SetProperty("System",
-                    new PropertyDescriptor(new NamespaceReference(engine, "System"), PropertyFlag.AllForbidden));
+#pragma warning disable IL2026
+
+                engine.Realm.GlobalObject.SetProperty("System", new PropertyDescriptor(new NamespaceReference(engine, "System"), PropertyFlag.AllForbidden));
+
                 engine.Realm.GlobalObject.SetProperty("importNamespace", new PropertyDescriptor(new ClrFunction(
                         engine,
                         "importNamespace",
                         (thisObj, arguments) =>
                             new NamespaceReference(engine, TypeConverter.ToString(arguments.At(0)))),
                     PropertyFlag.AllForbidden));
-                engine.Realm.GlobalObject.SetProperty("clrHelper", new PropertyDescriptor(
-                    new ObjectWrapper(engine, new ClrHelper(Interop)),
-                    PropertyFlag.AllForbidden));
+
+                engine.Realm.GlobalObject.SetProperty("clrHelper", new PropertyDescriptor(new ObjectWrapper(engine, new ClrHelper(Interop)), PropertyFlag.AllForbidden));
+
+#pragma warning restore IL2026
             }
 
             if (Interop.ExtensionMethodTypes.Count > 0)

diff --git a/Jint/Runtime/InternalTypes.cs b/Jint/Runtime/InternalTypes.cs
@@ -0,0 +1,37 @@
+namespace Jint.Runtime;
+
+[Flags]
+internal enum InternalTypes
+{
+    // should not be used, used for empty match
+    Empty = 0,
+
+    Undefined = 1,
+    Null = 2,
+
+    // primitive  types range start
+    Boolean = 4,
+    String = 8,
+    Number = 16,
+    Integer = 32,
+    Symbol = 64,
+    BigInt = 128,
+
+    // primitive  types range end
+    Object = 256,
+
+    PrivateName = 512,
+
+    // internal usage
+    ObjectEnvironmentRecord = 1024,
+    RequiresCloning = 2048,
+    Module = 4096,
+
+    // the object doesn't override important GetOwnProperty etc which change behavior
+    PlainObject = 8192,
+    // our native array
+    Array = 16384,
+
+    Primitive = Boolean | String | Number | Integer | BigInt | Symbol,
+    InternalFlags = ObjectEnvironmentRecord | RequiresCloning | PlainObject | Array | Module
+}
diff --git a/Jint/Runtime/Interop/ClrHelper.cs b/Jint/Runtime/Interop/ClrHelper.cs
@@ -1,8 +1,10 @@
-namespace Jint.Runtime.Interop;
+using Jint.Native;
 
-using Jint.Native;
+namespace Jint.Runtime.Interop;
 
-public class ClrHelper
+#pragma warning disable IL2072
+
+internal sealed class ClrHelper
 {
     private readonly Options.InteropOptions _interopOptions;
 
@@ -74,10 +76,8 @@ public JsValue ObjectToType(ObjectWrapper obj)
         {
             return TypeReference.CreateTypeReference(obj.Engine, t);
         }
-        else
-        {
-            ExceptionHelper.ThrowArgumentException("Must be an ObjectWrapper of Type", nameof(obj));
-        }
+
+        ExceptionHelper.ThrowArgumentException("Must be an ObjectWrapper of Type", nameof(obj));
         return JsValue.Undefined;
     }