Reduce generated IL code size

Directory.Build.props

@@ -7,5 +7,4 @@
     <ItemGroup>
         <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
     </ItemGroup>
-
-</Project>
+</Project>

src/XamlX.IL.Cecil/CecilEmitter.cs

@@ -132,6 +132,12 @@ public IXamlILEmitter Emit(SreOpCode code, int arg)
 
             public IXamlILEmitter Emit(SreOpCode code, long arg)
                 => Emit(Instruction.Create(Dic[code], arg));
+
+            public IXamlILEmitter Emit(SreOpCode code, sbyte arg)
+                => Emit(Instruction.Create(Dic[code], arg));
+
+            public IXamlILEmitter Emit(SreOpCode code, byte arg)
+                => Emit(Instruction.Create(Dic[code], arg));
 
             public IXamlILEmitter Emit(SreOpCode code, IXamlType type)
                 => Emit(Instruction.Create(Dic[code], Import(((ITypeReference) type).Reference)));
@@ -143,9 +149,11 @@ public IXamlILEmitter Emit(SreOpCode code, double arg)
                 => Emit(Instruction.Create(Dic[code], arg));
 
 
-            class CecilLocal : IXamlLocal
+            class CecilLocal : IXamlILLocal
             {
                 public VariableDefinition Variable { get; set; }
+
+                public int Index => Variable.Index;
             }
 
             class CecilLabel : IXamlLabel

src/XamlX.IL.Cecil/CecilField.cs

@@ -19,7 +19,9 @@ public CecilField(CecilTypeSystem typeSystem, FieldDefinition def, TypeReference
                 Field = new FieldReference(def.Name, def.FieldType, declaringType);
             }
 
-            public bool Equals(IXamlField other) => other is CecilField cf && cf.Field == Field;
+            public bool Equals(IXamlField other) => other is CecilField cf && cf.Field.FullName == Field.FullName;
+
+            public override int GetHashCode() => Field.FullName.GetHashCode();
 
             public string Name => Field.Name;
             private IXamlType _type;
@@ -41,4 +43,4 @@ public object GetLiteralValue()
             }
         }
     }
-}
+}

src/XamlX.IL.Cecil/CecilMethod.cs

@@ -102,6 +102,9 @@ other is CecilMethod cm
                 && DeclaringType.Equals(cm.DeclaringType)
                 && Reference.FullName == cm.Reference.FullName;
 
+            public override int GetHashCode() 
+                => (DeclaringType.GetHashCode() * 397) ^ Reference.FullName.GetHashCode();
+
             public IXamlMethod MakeGenericMethod(IReadOnlyList<IXamlType> typeArguments)
             {
                 GenericInstanceMethod instantiation = new GenericInstanceMethod(Reference);

src/XamlX.IL.Cecil/CecilType.cs

@@ -112,10 +112,9 @@ public bool IsAssignableFrom(IXamlType type)
             }
             bool IsAssignableFromCore(IXamlType type)
             {
-                if (!type.IsValueType
-                    && type == XamlPseudoType.Null)
-                    return true;
-
+                if (type == XamlPseudoType.Null)
+                    return !IsValueType || GenericTypeDefinition?.FullName == "System.Nullable`1";
+
                 if (type.IsValueType 
                     && GenericTypeDefinition?.FullName == "System.Nullable`1"
                     && GenericArguments[0].Equals(type))

src/XamlX/Ast/Clr.cs

@@ -87,33 +87,101 @@ public XamlAstClrProperty(IXamlLineInfo lineInfo, string name, IXamlType declari
         public override string ToString() => DeclaringType.GetFqn() + "." + Name;
     }
 
-    class XamlDirectCallPropertySetter : IXamlPropertySetter, IXamlEmitablePropertySetter<IXamlILEmitter>
+#if !XAMLX_INTERNAL
+    public
+#endif
+    interface IXamlILOptimizedEmitablePropertySetter : IXamlEmitablePropertySetter<IXamlILEmitter>
+    {
+        void EmitWithArguments(
+            XamlEmitContextWithLocals<IXamlILEmitter, XamlILNodeEmitResult> context,
+            IXamlILEmitter emitter,
+            IReadOnlyList<IXamlAstValueNode> arguments);
+    }
+
+    class XamlDirectCallPropertySetter : IXamlILOptimizedEmitablePropertySetter, IEquatable<XamlDirectCallPropertySetter>
     {
         private readonly IXamlMethod _method;
         public IXamlType TargetType { get; }
         public PropertySetterBinderParameters BinderParameters { get; } = new PropertySetterBinderParameters();
         public IReadOnlyList<IXamlType> Parameters { get; }
-        public void Emit(IXamlILEmitter codegen)
+
+        public void Emit(IXamlILEmitter emitter)
+            => emitter.EmitCall(_method, true);
+
+        public void EmitWithArguments(
+            XamlEmitContextWithLocals<IXamlILEmitter, XamlILNodeEmitResult> context,
+            IXamlILEmitter emitter,
+            IReadOnlyList<IXamlAstValueNode> arguments)
         {
-            codegen.EmitCall(_method, true);
+            for (var i = 0; i < arguments.Count; ++i)
+                context.Emit(arguments[i], emitter, Parameters[i]);
+
+            emitter.EmitCall(_method, true);
         }
 
         public XamlDirectCallPropertySetter(IXamlMethod method)
         {
             _method = method;
             Parameters = method.ParametersWithThis().Skip(1).ToList();
             TargetType = method.ThisOrFirstParameter();
+
+            bool allowNull = Parameters.Last().AcceptsNull();
+            BinderParameters = new PropertySetterBinderParameters
+            {
+                AllowMultiple = false,
+                AllowXNull = allowNull,
+                AllowRuntimeNull = allowNull
+            };
+        }
+
+        public bool Equals(XamlDirectCallPropertySetter other)
+        {
+            if (ReferenceEquals(null, other))
+                return false;
+            if (ReferenceEquals(this, other))
+                return true;
+
+            return _method.Equals(other._method) && BinderParameters.Equals(other.BinderParameters);
         }
+
+        public override bool Equals(object obj)
+            => Equals(obj as XamlDirectCallPropertySetter);
+
+        public override int GetHashCode() 
+            => (_method.GetHashCode() * 397) ^ BinderParameters.GetHashCode();
     }
 
 #if !XAMLX_INTERNAL
     public
 #endif
-    class PropertySetterBinderParameters
+    class PropertySetterBinderParameters : IEquatable<PropertySetterBinderParameters>
     {
         public bool AllowMultiple { get; set; }
         public bool AllowXNull { get; set; } = true;
         public bool AllowRuntimeNull { get; set; } = true;
+
+        public bool Equals(PropertySetterBinderParameters other)
+        {
+            if (ReferenceEquals(null, other))
+                return false;
+            if (ReferenceEquals(this, other))
+                return true;
+
+            return AllowMultiple == other.AllowMultiple 
+                   && AllowXNull == other.AllowXNull
+                   && AllowRuntimeNull == other.AllowRuntimeNull;
+        }
+
+        public override bool Equals(object obj) 
+            => Equals(obj as PropertySetterBinderParameters);
+
+        public override int GetHashCode()
+        {
+            int hashCode = AllowMultiple.GetHashCode();
+            hashCode = (hashCode * 397) ^ AllowXNull.GetHashCode();
+            hashCode = (hashCode * 397) ^ AllowRuntimeNull.GetHashCode();
+            return hashCode;
+        }
     }
 
 #if !XAMLX_INTERNAL
@@ -637,6 +705,8 @@ void CompileBuilder(ILEmitContext context)
 
             context.Emit(Value, context.Emitter, context.Configuration.WellKnownTypes.Object);
             il.Ret();
+
+            context.ExecuteAfterEmitCallbacks();
         }
 
         public XamlILNodeEmitResult Emit(XamlEmitContext<IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
@@ -652,7 +722,7 @@ public XamlILNodeEmitResult Emit(XamlEmitContext<IXamlILEmitter, XamlILNodeEmitR
                 context.EmitMappings, runtimeContext: context.RuntimeContext,
                 contextLocal: buildMethod.Generator.DefineLocal(context.RuntimeContext.ContextType),
                 createSubType: (s, type) => subType.DefineSubType(type, s, false),
-                defineDelegateSubType: (s, returnType, parameters) => subType.DefineDelegateSubType(s, false, returnType, parameters), 
+                defineDelegateSubType: (s, returnType, parameters) => subType.DefineDelegateSubType(s, false, returnType, parameters),
                 file: context.File,
                 emitters: context.Emitters));
 
@@ -662,11 +732,11 @@ public XamlILNodeEmitResult Emit(XamlEmitContext<IXamlILEmitter, XamlILNodeEmitR
                 .Ldftn(buildMethod)
                 .Newobj(funcType.Constructors.FirstOrDefault(ct =>
                     ct.Parameters.Count == 2 && ct.Parameters[0].Equals(context.Configuration.WellKnownTypes.Object)));
-            
+
             // Allow to save values from the parent context, pass own service provider, etc, etc
             if (context.Configuration.TypeMappings.DeferredContentExecutorCustomization != null)
             {
-                
+
                 var customization = context.Configuration.TypeMappings.DeferredContentExecutorCustomization;
                 if (_deferredContentCustomizationTypeParameter != null)
                     customization =

src/XamlX/Ast/Intrinsics.cs

@@ -25,7 +25,7 @@ public XamlILNodeEmitResult Emit(XamlEmitContext<IXamlILEmitter, XamlILNodeEmitR
             codeGen.Emit(OpCodes.Ldnull);
             return XamlILNodeEmitResult.Type(0, XamlPseudoType.Null);
         }
-    }
+    }
 
 #if !XAMLX_INTERNAL
     public
@@ -165,7 +165,7 @@ public XamlILNodeEmitResult Emit(XamlEmitContext<IXamlILEmitter, XamlILNodeEmitR
             else if (Constant is bool b)
                 codeGen.Emit(b ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0);
             else
-                codeGen.Emit(OpCodes.Ldc_I4, TypeSystem.TypeSystemHelpers.ConvertLiteralToInt(Constant));
+                codeGen.Ldc_I4(TypeSystem.TypeSystemHelpers.ConvertLiteralToInt(Constant));
             return XamlILNodeEmitResult.Type(0, Type.GetClrType());
         }
     }

src/XamlX/Emit/XamlEmitContext.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using System.Xml;
 using XamlX.Ast;
 using XamlX.Transform;
@@ -18,6 +17,7 @@ abstract class XamlEmitContext<TBackendEmitter, TEmitResult> : XamlContextBase
         public IFileSource File { get; }
         public List<object> Emitters { get; }
 
+        private readonly List<Action> _afterEmitCallbacks = new();
         private IXamlAstNode _currentNode;
 
         public TransformerConfiguration Configuration { get; }
@@ -217,6 +217,17 @@ protected virtual TEmitResult EmitNodeCore(IXamlAstNode value, TBackendEmitter c
             foundEmitter = false;
             return res;
         }
+
+        public void AddAfterEmitCallbacks(Action callback)
+            => _afterEmitCallbacks.Add(callback);
+
+        public void ExecuteAfterEmitCallbacks()
+        {
+            foreach (var callback in _afterEmitCallbacks)
+                callback();
+
+            _afterEmitCallbacks.Clear();
+        }
     }
 
 #if !XAMLX_INTERNAL

src/XamlX/IL/CheckingIlEmitter.cs

@@ -238,6 +238,20 @@ public IXamlILEmitter Emit(OpCode code, long arg)
             return this;
         }
 
+        public IXamlILEmitter Emit(OpCode code, sbyte arg)
+        {
+            Track(code, arg);
+            _inner.Emit(code, arg);
+            return this;
+        }
+
+        public IXamlILEmitter Emit(OpCode code, byte arg)
+        {
+            Track(code, arg);
+            _inner.Emit(code, arg);
+            return this;
+        }
+
         public IXamlILEmitter Emit(OpCode code, IXamlType type)
         {
             Track(code, type);

src/XamlX/IL/Emitters/MarkupExtensionEmitter.cs

@@ -36,7 +36,7 @@ void EmitPropertyDescriptor()
 
             if (me.ProvideValue.Parameters.Count > 0)
                 ilgen
-                    .Emit(OpCodes.Ldloc, context.ContextLocal);
+                    .Ldloc(context.ContextLocal);
 
             if (needProvideValueTarget)
             {