WIP: Fix for looking up fields and methods in CallSites with Typebuilder generic args.

dmiller · dmiller · commit 1a146e6c09a4 · 2025-03-20T17:32:36.000-04:00
diff --git a/Clojure/Clojure/CljCompiler/Ast/InstanceZeroArityCallExpr.cs b/Clojure/Clojure/CljCompiler/Ast/InstanceZeroArityCallExpr.cs
@@ -133,13 +133,13 @@ public override void EmitUnboxed(RHC rhc, ObjExpr objx, CljILGen ilg)
             DynamicExpression dyn = Expression.Dynamic(binder, returnType, paramExprs);
 
 
-            MethodExpr.EmitDynamicCallPreamble(dyn, _spanMap, "__interop_" + _memberName + RT.nextID(), returnType, paramExprs, paramTypes.ToArray(), ilg, out LambdaExpression lambda, out Type delType, out MethodBuilder mbLambda);
+            MethodExpr.EmitDynamicCallPreamble(dyn, _spanMap, "__interop_" + _memberName + RT.nextID(), returnType, paramExprs, paramTypes.ToArray(), ilg, out Type delType, out MethodBuilder mbLambda);
 
             //  Emit target + args (no args, actually)
 
             _target.Emit(RHC.Expression, objx, ilg);
 
-            MethodExpr.EmitDynamicCallPostlude(lambda, delType, mbLambda, ilg);
+            MethodExpr.EmitDynamicCallPostlude(mbLambda, ilg);
  
         }
 
diff --git a/Clojure/Clojure/CljCompiler/Ast/MethodExpr.cs b/Clojure/Clojure/CljCompiler/Ast/MethodExpr.cs
@@ -17,6 +17,8 @@
 using System.Linq.Expressions;
 using System.Reflection;
 using System.Reflection.Emit;
+using System.Runtime.CompilerServices;
+using static clojure.lang.CljCompiler.Context.DynInitHelper;
 
 namespace clojure.lang.CljCompiler.Ast
 {
@@ -164,31 +166,6 @@ public static void CacheDelegate(int key, Delegate d)
 
         private void EmitComplexCall(ObjExpr objx, CljILGen ilg)
         {
-            // TODO: We have gotten rid of light-compile. Simplify this.
-            // This is made more complex than I'd like by light-compiling.
-            // Without light-compile, we could just:
-            //   Emit the target expression
-            //   Emit the arguments (and build up the parameter list for the lambda)
-            //   Create the lambda, compile to a methodbuilder, and call it.
-            // Light-compile forces us to 
-            //     create a lambda at the beginning because we must 
-            //     compile it to a delegate, to get the type
-            //     write code to grab the delegate from a cache
-            //     Then emit the target expression
-            //          emit the arguments (but note we need already to have built the parameter list)
-            //          Call the delegate
-            //  Combined, this becomes
-            //      Build the parameter list
-            //      Build the dynamic call and lambda  (slightly different for light-compile vs full)
-            //      if light-compile
-            //          build the delegate
-            //          cache it
-            //          emit code to retrieve and cast it
-            //       emit the target expression
-            //       emit the args
-            //       emit the call (slightly different for light compile vs full)
-            //
-
             //  Build the parameter list
 
             List<ParameterExpression> paramExprs = new List<ParameterExpression>(_args.Count + 1);
@@ -260,7 +237,7 @@ private void EmitComplexCall(ObjExpr objx, CljILGen ilg)
             Type dynType = dih.MakeDelegateType("__interop__", callsiteParamTypes.ToArray(), returnType);
 
             DynamicExpression dyn = Expression.MakeDynamic(dynType, binder, paramExprs);
-            EmitDynamicCallPreamble(dyn, _spanMap, "__interop_" + _methodName + RT.nextID(), returnType, paramExprs, paramTypes.ToArray(), ilg, out LambdaExpression lambda, out Type delType, out MethodBuilder mbLambda);
+            EmitDynamicCallPreamble(dyn, _spanMap, "__interop_" + _methodName + RT.nextID(), returnType, paramExprs, paramTypes.ToArray(), ilg, out Type delType, out MethodBuilder mbLambda);
 
             //  Emit target + args
 
@@ -295,7 +272,7 @@ private void EmitComplexCall(ObjExpr objx, CljILGen ilg)
                 }
             }
 
-            EmitDynamicCallPostlude(lambda, delType, mbLambda, ilg);
+            EmitDynamicCallPostlude(mbLambda, ilg);
         }
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0060:Remove unused parameter", Justification = "Standard API")]
         public static void EmitByRefArg(HostArg ha, ObjExpr objx, CljILGen ilg)
@@ -308,116 +285,71 @@ public static void EmitByRefArg(HostArg ha, ObjExpr objx, CljILGen ilg)
                 ilg.Emit(OpCodes.Ldloca, ha.LocalBinding.LocalVar);
         }
 
-        static public void EmitDynamicCallPreamble(DynamicExpression dyn, IPersistentMap spanMap, string methodName, Type returnType, IList<ParameterExpression> paramExprs, Type[] paramTypes, CljILGen ilg, out LambdaExpression lambda, out Type delType, out MethodBuilder mbLambda)
+        static readonly FieldInfo FI_CallSite_Target = typeof(CallSite<>).GetField("Target", BindingFlags.Instance | BindingFlags.Public);
+        static FieldInfo GetCallSiteTarget(Type siteType)
         {
-            GenContext context = Compiler.CompilerContextVar.deref() as GenContext;
-            DynInitHelper.SiteInfo siteInfo;
-            Expression call;
-            if (context != null && context.DynInitHelper != null)
-                call = context.DynInitHelper.ReduceDyn(dyn, out siteInfo);
+            if (siteType is TypeBuilder || siteType.GetGenericArguments()[0] is TypeBuilder )
+                return TypeBuilder.GetField(siteType, FI_CallSite_Target);
             else
-                throw new InvalidOperationException("Don't know how to handle callsite in this case");
+                return siteType.GetField("Target", BindingFlags.Instance | BindingFlags.Public);
+        }
 
-            if (returnType == typeof(void))
-            {
-                call = Expression.Block(call, Expression.Default(typeof(object)));
-                returnType = typeof(object);
-            }
-            else if (returnType != call.Type)
-            {
-                call = Expression.Convert(call, returnType);
-            }
 
-            call = GenContext.AddDebugInfo(call, spanMap);
+        static public void EmitDynamicCallPreamble(DynamicExpression dyn, IPersistentMap spanMap, string methodName, Type returnType, IList<ParameterExpression> paramExprs, Type[] paramTypes, CljILGen ilg, out Type delType, out MethodBuilder mbLambda)
+        {
+            GenContext context = Compiler.CompilerContextVar.deref() as GenContext;
+            
+            if (context is null || context.DynInitHelper is null)
+                throw new InvalidOperationException("Don't know how to handle callsite in this case");
 
+            DynInitHelper.SiteInfo siteInfo = context.DynInitHelper.ComputeSiteInfo(dyn);
 
             // PLAN9 : seeing if we can replace this
             // delType = Microsoft.Scripting.Generation.Snippets.Shared.DefineDelegate("__interop__", returnType, paramTypes);
             delType = context.DynInitHelper.MakeDelegateType("__interop__", paramTypes, returnType);
 
-            lambda = null;
-            mbLambda = null;
-            
-            if (context == null)
+            mbLambda = context.TB.DefineMethod(methodName, MethodAttributes.Static | MethodAttributes.Public, CallingConventions.Standard, returnType, paramTypes);
+            //lambda.CompileToMethod(mbLambda);
+            // Now we get to do all this code create by hand.
+            // the primary code is
+            // (loc1 = fb).Target.Invoke(loc1,*args);
+            // if return type if void, pop the value and push a null
+            // if return type does not match the call site, add a conversion
+            CljILGen ilg2 = new CljILGen(mbLambda.GetILGenerator());
+            ilg2.EmitFieldGet(siteInfo.FieldBuilder);
+            ilg2.Emit(OpCodes.Dup);
+            LocalBuilder siteVar = ilg2.DeclareLocal(siteInfo.SiteType);
+            ilg2.Emit(OpCodes.Stloc, siteVar);
+
+            var targetFI = GetCallSiteTarget(siteInfo.SiteType);    //  siteInfo.SiteType.GetField("Target");
+
+            ilg2.EmitFieldGet(targetFI);
+
+            ilg2.Emit(OpCodes.Ldloc, siteVar);
+            for (int i = 0; i < paramExprs.Count; i++)
+                ilg2.EmitLoadArg(i);
+
+            var invokeMethod = siteInfo.DelegateType.GetMethod("Invoke");
+            ilg2.EmitCall(invokeMethod);
+            if (returnType == typeof(void))
             {
-                // light compile
-
-                lambda = Expression.Lambda(delType, call, paramExprs);
-
-                Delegate d = lambda.Compile();
-                int key = RT.nextID();
-                CacheDelegate(key, d);
- 
-                ilg.EmitInt(key);
-                ilg.Emit(OpCodes.Call, Method_MethodExpr_GetDelegate);
-                ilg.Emit(OpCodes.Castclass, delType);
+                ilg2.Emit(OpCodes.Pop);
+                ilg2.EmitNull();
             }
-            else
+            else if (returnType != invokeMethod.ReturnType)
             {
-                mbLambda = context.TB.DefineMethod(methodName, MethodAttributes.Static | MethodAttributes.Public, CallingConventions.Standard, returnType, paramTypes);
-                //lambda.CompileToMethod(mbLambda);
-                // Now we get to do all this code create by hand.
-                // the primary code is
-                // (loc1 = fb).Target.Invoke(loc1,*args);
-                // if return type if void, pop the value and push a null
-                // if return type does not match the call site, add a conversion
-                CljILGen ilg2 = new CljILGen(mbLambda.GetILGenerator());
-                ilg2.EmitFieldGet(siteInfo.FieldBuilder);
-                ilg2.Emit(OpCodes.Dup);
-                LocalBuilder siteVar = ilg2.DeclareLocal(siteInfo.SiteType);
-                ilg2.Emit(OpCodes.Stloc, siteVar);
-                ilg2.EmitFieldGet(siteInfo.SiteType.GetField("Target"));
-                ilg2.Emit(OpCodes.Ldloc, siteVar);
-                for (int i = 0; i < paramExprs.Count; i++)
-                    ilg2.EmitLoadArg(i);
-
-                var invokeMethod = siteInfo.DelegateType.GetMethod("Invoke");
-                ilg2.EmitCall(invokeMethod);
-                if (returnType == typeof(void))
-                {
-                    ilg2.Emit(OpCodes.Pop);
-                    ilg2.EmitNull();
-                }
-                else if (returnType != invokeMethod.ReturnType)
-                {
-                    EmitConvertToType(ilg2, invokeMethod.ReturnType, returnType, false);
-                }
-
-                ilg2.Emit(OpCodes.Ret);
-
-
-                    /*
-                     *             return Expression.Block(
-                new[] { site },
-                Expression.Call(
-                    Expression.Field(
-                        Expression.Assign(site, access),
-                        cs.GetType().GetField("Target")
-                    ),
-                    node.DelegateType.GetMethod("Invoke"),
-                    ClrExtensions.ArrayInsert(site, node.Arguments)
-                )
-                */
-
-
+                EmitConvertToType(ilg2, invokeMethod.ReturnType, returnType, false);
             }
+
+            ilg2.Emit(OpCodes.Ret);
         }
 
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0060:Remove unused parameter", Justification = "Standard API")]
-        static public void EmitDynamicCallPostlude(LambdaExpression lambda, Type delType, MethodBuilder mbLambda, CljILGen ilg)
+        static public void EmitDynamicCallPostlude(MethodBuilder mbLambda, CljILGen ilg)
         {
-            if (!(Compiler.CompilerContextVar.deref() is GenContext))
-            {
-                // light compile
-
-                MethodInfo mi = delType.GetMethod("Invoke");
-                ilg.Emit(OpCodes.Callvirt, mi);
-            }
-            else
-            {
-                ilg.Emit(OpCodes.Call, mbLambda);
-            }
+            ilg.Emit(OpCodes.Call, mbLambda);
         }
+        
 
         internal static void EmitArgsAsArray(IPersistentVector args, ObjExpr objx, CljILGen ilg)
         {
diff --git a/Clojure/Clojure/CljCompiler/Ast/NewExpr.cs b/Clojure/Clojure/CljCompiler/Ast/NewExpr.cs
@@ -251,7 +251,7 @@ private void EmitComplexCall(RHC rhc, ObjExpr objx, CljILGen ilg)
             CreateInstanceBinder binder = new ClojureCreateInstanceBinder(ClojureContext.Default, _args.Count);
             DynamicExpression dyn = Expression.Dynamic(binder, typeof(object), paramExprs);
 
-            MethodExpr.EmitDynamicCallPreamble(dyn, _spanMap, "__interop_ctor_" + RT.nextID(), returnType, paramExprs, paramTypes.ToArray(), ilg, out LambdaExpression lambda, out Type delType, out MethodBuilder mbLambda);
+            MethodExpr.EmitDynamicCallPreamble(dyn, _spanMap, "__interop_ctor_" + RT.nextID(), returnType, paramExprs, paramTypes.ToArray(), ilg, out Type delType, out MethodBuilder mbLambda);
 
             //  Emit target + args
 
@@ -286,7 +286,7 @@ private void EmitComplexCall(RHC rhc, ObjExpr objx, CljILGen ilg)
                 }
             }
             
-            MethodExpr.EmitDynamicCallPostlude(lambda, delType, mbLambda, ilg); 
+            MethodExpr.EmitDynamicCallPostlude(mbLambda, ilg); 
         }
 
         private void EmitTargetExpression(ObjExpr objx, CljILGen ilg)
diff --git a/Clojure/Clojure/CljCompiler/Ast/StaticInvokeExpr.cs b/Clojure/Clojure/CljCompiler/Ast/StaticInvokeExpr.cs
@@ -183,6 +183,7 @@ public void EmitUnboxed(RHC rhc, ObjExpr objx, CljILGen ilg)
             else
                 MethodExpr.EmitTypedArgs(objx, ilg, _method.GetParameters(), _args);
 
+            Console.WriteLine($"{_method.DeclaringType.FullName} . {_method.Name}, {_method.ToString()}");
             ilg.EmitCall(_method);
         }
 
diff --git a/Clojure/Clojure/CljCompiler/Compiler.cs b/Clojure/Clojure/CljCompiler/Compiler.cs
@@ -10,6 +10,7 @@
 
 using clojure.lang.CljCompiler.Ast;
 using clojure.lang.CljCompiler.Context;
+using Microsoft.Scripting.Runtime;
 using System;
 using System.Collections;
 using System.Collections.Generic;
@@ -1813,6 +1814,12 @@ private static void Compile1(TypeBuilder tb, CljILGen ilg,  ObjExpr objx, object
 
             try
             {
+                {
+                    var item = RT.first(form);
+                    if (item is Symbol s && s.Name.Equals("definline"))
+                        Console.WriteLine("definline!");
+                }
+
                 form = Macroexpand(form);
                 if (form is ISeq && Util.Equals(RT.first(form), DoSym))
                 {
diff --git a/Clojure/Clojure/CljCompiler/Context/DynInitHelper.cs b/Clojure/Clojure/CljCompiler/Context/DynInitHelper.cs
@@ -93,7 +93,7 @@ public DynInitHelper(AssemblyGenT ag, string typeName)
         /// <summary>
         /// Reduces the provided DynamicExpression into site.Target(site, *args).
         /// </summary>
-        public Expression ReduceDyn(DynamicExpression node, out SiteInfo siteInfo)
+        public SiteInfo ComputeSiteInfo(DynamicExpression node)
         {
             MaybeInit();
 
@@ -102,25 +102,20 @@ public Expression ReduceDyn(DynamicExpression node, out SiteInfo siteInfo)
                 node = Expression.MakeDynamic(delegateType, node.Binder, node.Arguments);
             }
 
-            CallSite cs = CallSite.Create(node.DelegateType, node.Binder);
-            // TODO: fix this eventually to return the SiteInfo and not the Expression
-
-            Expression access = RewriteCallSite(cs, _typeGen, delegateType ?? node.DelegateType, out siteInfo);
-
-            // ($site = siteExpr).Target.Invoke($site, *args)
-            ParameterExpression site = Expression.Variable(cs.GetType(), "$site");
-
-            return Expression.Block(
-                new[] { site },
-                Expression.Call(
-                    Expression.Field(
-                        Expression.Assign(site, access),
-                        cs.GetType().GetField("Target")
-                    ),
-                    node.DelegateType.GetMethod("Invoke"),
-                    ClrExtensions.ArrayInsert(site, node.Arguments)
-                )
-            );
+            var binder = node.Binder;
+            if (binder is not IExpressionSerializable)
+            {
+                throw new ArgumentException("Generating code from non-serializable CallSiteBinder.");
+            }
+
+            Type delegateToUse = delegateType ?? node.DelegateType;
+            Type siteType = typeof(CallSite<>).MakeGenericType(delegateToUse);
+            FieldBuilder fb = _typeGen.AddStaticField(siteType, "sf" + _id++.ToString());
+
+            var siteInfo = new SiteInfo(fb, siteType, binder, delegateToUse);
+            _siteInfos.Add(siteInfo);
+
+            return siteInfo;
         }
 
         private void MaybeInit()
@@ -133,23 +128,6 @@ private void MaybeInit()
             }
         }
 
-
-        private Expression RewriteCallSite(CallSite site, TypeGenT tg, Type delegateType, out SiteInfo siteInfo)
-        {
-            if (!(site.Binder is IExpressionSerializable))
-            {
-                throw new ArgumentException("Generating code from non-serializable CallSiteBinder.");
-            }
-
-            Type siteType = site.GetType();
-            FieldBuilder fb = tg.AddStaticField(siteType, "sf" + _id++.ToString());
-            siteInfo = new SiteInfo(fb, siteType, site.Binder, delegateType);
-            _siteInfos.Add(siteInfo);
-
-            // rewrite the node...
-            return Expression.Field(null, fb);
-        }
-
         #endregion
 
         #region DLR code generation : stolen code
@@ -341,7 +319,7 @@ public Type MakeDelegateType(string name, Type[] parameters, Type returnType)
             method.SetImplementationFlags(ImplAttributes);
 #endif
 
-            return builder.CreateTypeInfo();
+            return builder.CreateType();
         }
 
         private const MethodAttributes CtorAttributes = MethodAttributes.RTSpecialName | MethodAttributes.HideBySig | MethodAttributes.Public;
@@ -363,6 +341,16 @@ public void FinalizeType()
             }
         }
 
+        static readonly MethodInfo MI_CallSite_Create = typeof(CallSite<>).GetMethod("Create", BindingFlags.Static | BindingFlags.Public);
+        static MethodInfo GetCallSiteCreateMethod(Type siteType)
+        {
+            if (siteType is TypeBuilder || siteType.GetGenericArguments()[0] is TypeBuilder)
+                return TypeBuilder.GetMethod(siteType, MI_CallSite_Create);
+            else
+                return siteType.GetMethod("Create", BindingFlags.Static | BindingFlags.Public);
+        }
+
+
         void CreateStaticCtor()
         {
             ConstructorBuilder ctorB = _typeBuilder.DefineConstructor(MethodAttributes.Static | MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes);
@@ -386,7 +374,9 @@ void CreateStaticCtor()
                     throw new InvalidOperationException("Binder of unknown type");
                 b.GenerateCreationIL(mbSetter.GetILGenerator());
 
-                setterIlg.EmitCall(si.SiteType.GetMethod("Create"));
+                //setterIlg.EmitCall(si.SiteType.GetMethod("Create"));
+                setterIlg.EmitCall(GetCallSiteCreateMethod(si.SiteType));
+
                 setterIlg.Emit(OpCodes.Dup);
                 LocalBuilder v0 = setterIlg.DeclareLocal(si.FieldBuilder.FieldType);
                 setterIlg.Emit(OpCodes.Stloc, v0);

Original file line number	Diff line number	Diff line change
`@@ -133,13 +133,13 @@ public override void EmitUnboxed(RHC rhc, ObjExpr objx, CljILGen ilg)`
`133`	`133`	`DynamicExpression dyn = Expression.Dynamic(binder, returnType, paramExprs);`
`134`	`134`
`135`	`135`
`136`		`- MethodExpr.EmitDynamicCallPreamble(dyn, _spanMap, "__interop_" + _memberName + RT.nextID(), returnType, paramExprs, paramTypes.ToArray(), ilg, out LambdaExpression lambda, out Type delType, out MethodBuilder mbLambda);`
	`136`	`+ MethodExpr.EmitDynamicCallPreamble(dyn, _spanMap, "__interop_" + _memberName + RT.nextID(), returnType, paramExprs, paramTypes.ToArray(), ilg, out Type delType, out MethodBuilder mbLambda);`
`137`	`137`
`138`	`138`	`// Emit target + args (no args, actually)`
`139`	`139`
`140`	`140`	`_target.Emit(RHC.Expression, objx, ilg);`
`141`	`141`
`142`		`- MethodExpr.EmitDynamicCallPostlude(lambda, delType, mbLambda, ilg);`
	`142`	`+ MethodExpr.EmitDynamicCallPostlude(mbLambda, ilg);`
`143`	`143`
`144`	`144`	`}`
`145`	`145`
Original file line number	Diff line number	Diff line change
`@@ -251,7 +251,7 @@ private void EmitComplexCall(RHC rhc, ObjExpr objx, CljILGen ilg)`
`251`	`251`	`CreateInstanceBinder binder = new ClojureCreateInstanceBinder(ClojureContext.Default, _args.Count);`
`252`	`252`	`DynamicExpression dyn = Expression.Dynamic(binder, typeof(object), paramExprs);`
`253`	`253`
`254`		`- MethodExpr.EmitDynamicCallPreamble(dyn, _spanMap, "__interop_ctor_" + RT.nextID(), returnType, paramExprs, paramTypes.ToArray(), ilg, out LambdaExpression lambda, out Type delType, out MethodBuilder mbLambda);`
	`254`	`+ MethodExpr.EmitDynamicCallPreamble(dyn, _spanMap, "__interop_ctor_" + RT.nextID(), returnType, paramExprs, paramTypes.ToArray(), ilg, out Type delType, out MethodBuilder mbLambda);`
`255`	`255`
`256`	`256`	`// Emit target + args`
`257`	`257`
`@@ -286,7 +286,7 @@ private void EmitComplexCall(RHC rhc, ObjExpr objx, CljILGen ilg)`
`286`	`286`	`}`
`287`	`287`	`}`
`288`	`288`
`289`		`- MethodExpr.EmitDynamicCallPostlude(lambda, delType, mbLambda, ilg);`
	`289`	`+ MethodExpr.EmitDynamicCallPostlude(mbLambda, ilg);`
`290`	`290`	`}`
`291`	`291`
`292`	`292`	`private void EmitTargetExpression(ObjExpr objx, CljILGen ilg)`
Original file line number	Diff line number	Diff line change
`@@ -183,6 +183,7 @@ public void EmitUnboxed(RHC rhc, ObjExpr objx, CljILGen ilg)`
`183`	`183`	`else`
`184`	`184`	`MethodExpr.EmitTypedArgs(objx, ilg, _method.GetParameters(), _args);`
`185`	`185`
	`186`	`+ Console.WriteLine($"{_method.DeclaringType.FullName} . {_method.Name}, {_method.ToString()}");`
`186`	`187`	`ilg.EmitCall(_method);`
`187`	`188`	`}`
`188`	`189`